{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shapley value analysis for Chemprop models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook demonstrates how to perform Shapley (SHAP) value analysis for a chemprop model. In addition, it also serves as an example on how to customize chemprop featurizers.\n",
    "\n",
    "* Example 1: Shapley value analysis to explain importance of default chemprop atom and bond features\n",
    "* Example 2: Shapley value analysis to explain importance of particular atom/node and bond/edge\n",
    "* Example 3: Shapley value analysis to explain importance of extra features (not yet implemented, will be done in the future release, this is likely eaiser to be achieved by modifying MoleculeDatapoint and dataloader functions)\n",
    "\n",
    "Disclaimer: This notebook is for feature demonstration purposes only. The models used in this notebook are not trained models, and the computed Shapley values are provided solely for illustrative purposes. \n",
    "\n",
    "Note: This notebook is developed for Chemprop v2. \n",
    "\n",
    "For Chemprop v1 SHAP implementation checkout: https://github.com/oscarwumit/chemprop_developing/tree/shap_v1\n",
    "\n",
    "This notebook requires the SHAP package, do \"pip install shap\" if you don't have it installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/chemprop/chemprop/blob/main/examples/shapley_value_with_customized_featurizers.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install chemprop from GitHub if running in Google Colab\n",
    "import os\n",
    "\n",
    "if os.getenv(\"COLAB_RELEASE_TAG\"):\n",
    "    try:\n",
    "        import chemprop\n",
    "    except ImportError:\n",
    "        !git clone https://github.com/chemprop/chemprop.git\n",
    "        %cd chemprop\n",
    "        !pip install .\n",
    "        !pip install shap\n",
    "        %cd examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Citation for SHAP implementation in Chemprop\n",
    "\n",
    "Li & Wu, et al. “When Do Quantum Mechanical Descriptors Help Graph Neural Networks to Predict Chemical Properties?” Journal of the American Chemical Society, vol. 146, no. 33, Aug. 2024, pp. 23103–20. https://doi.org/10.1021/jacs.4c04670.\n",
    "\n",
    "Bibtex format\n",
    "<pre>\n",
    "@article{li_and_wu_qm_des_2024, \n",
    "\ttitle = {When {Do} {Quantum} {Mechanical} {Descriptors} {Help} {Graph} {Neural} {Networks} to {Predict} {Chemical} {Properties}?}, \n",
    "\tvolume = {146}, \n",
    "\tcopyright = {https://doi.org/10.15223/policy-029}, \n",
    "\tissn = {0002-7863, 1520-5126}, \n",
    "\turl = {https://pubs.acs.org/doi/10.1021/jacs.4c04670}, \n",
    "\tdoi = {10.1021/jacs.4c04670}, \n",
    "\tlanguage = {en}, \n",
    "\tnumber = {33}, \n",
    "\turldate = {2025-01-13}, \n",
    "\tjournal = {Journal of the American Chemical Society}, \n",
    "\tauthor = {Li, Shih-Cheng and Wu, Haoyang and Menon, Angiras and Spiekermann, Kevin A. and Li, Yi-Pei and Green, William H.}, \n",
    "\tmonth = aug, \n",
    "\tyear = {2024}, \n",
    "\tpages = {23103--23120}, \n",
    "} \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customize Chemprop featurizers for SHAP analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dependencies and classes\n",
    "import sys\n",
    "\n",
    "from copy import deepcopy\n",
    "from lightning import pytorch as pl\n",
    "from pathlib import Path\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "from dataclasses import InitVar, dataclass\n",
    "from typing import List, Sequence, Tuple, Union, Optional\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import Mol, Draw\n",
    "from rdkit.Chem.rdchem import Atom, Bond, BondType\n",
    "\n",
    "from chemprop.featurizers.atom import MultiHotAtomFeaturizer \n",
    "from chemprop.featurizers.bond import MultiHotBondFeaturizer \n",
    "from chemprop.featurizers.molgraph.molecule import SimpleMoleculeMolGraphFeaturizer \n",
    "\n",
    "from chemprop.data.molgraph import MolGraph \n",
    "from chemprop.featurizers.base import GraphFeaturizer \n",
    "from chemprop.featurizers.molgraph.mixins import _MolGraphFeaturizerMixin \n",
    "\n",
    "from chemprop import data, featurizers, models \n",
    "\n",
    "import shap # do \"pip install shap\" if you don't have it installed\n",
    "\n",
    "import logging\n",
    "\n",
    "# Set logging level to WARNING to suppress INFO logs\n",
    "logging.getLogger(\"lightning.pytorch.utilities.rank_zero\").setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CustomMultiHotAtomFeaturizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomMultiHotAtomFeaturizer(MultiHotAtomFeaturizer):\n",
    "    \"\"\"A custom MultiHotAtomFeaturizer that allows for selective feature ablation.\n",
    "        \n",
    "    Parameters\n",
    "    ----------\n",
    "    keep_features : List[bool], optional\n",
    "        a list of booleans to indicate which atom features to keep. If None, all features are kept. For any element that is False, the corresponding feature's encoding is set to all zeros. Useful for ablation and SHAP analysis.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,\n",
    "                 atomic_nums: Sequence[int],\n",
    "                 degrees: Sequence[int],\n",
    "                 formal_charges: Sequence[int],\n",
    "                 chiral_tags: Sequence[int],\n",
    "                 num_Hs: Sequence[int],\n",
    "                 hybridizations: Sequence[int],\n",
    "                 keep_features: List[bool] = None):\n",
    "        super().__init__(atomic_nums, degrees, formal_charges, chiral_tags, num_Hs, hybridizations)\n",
    "        \n",
    "        if keep_features is None:\n",
    "            keep_features = [True] * (len(self._subfeats) + 2)\n",
    "        self.keep_features = keep_features\n",
    "\n",
    "    def __call__(self, a: Atom | None) -> np.ndarray:\n",
    "        x = np.zeros(self._MultiHotAtomFeaturizer__size)\n",
    "        if a is None:\n",
    "            return x\n",
    "        \n",
    "        feats = [\n",
    "            a.GetAtomicNum(),\n",
    "            a.GetTotalDegree(),\n",
    "            a.GetFormalCharge(),\n",
    "            int(a.GetChiralTag()),\n",
    "            int(a.GetTotalNumHs()),\n",
    "            a.GetHybridization(),\n",
    "        ]\n",
    "        \n",
    "        i = 0\n",
    "        for feat, choices, keep in zip(feats, self._subfeats, self.keep_features[:len(feats)]):\n",
    "            j = choices.get(feat, len(choices))\n",
    "            if keep:\n",
    "                x[i + j] = 1\n",
    "            i += len(choices) + 1\n",
    "        \n",
    "        if self.keep_features[len(feats)]:\n",
    "            x[i] = int(a.GetIsAromatic())\n",
    "        if self.keep_features[len(feats) + 1]:\n",
    "            x[i + 1] = 0.01 * a.GetMass()\n",
    "\n",
    "        return x\n",
    "\n",
    "    def zero_mask(self) -> np.ndarray:\n",
    "        \"\"\"Featurize the atom by setting all bits to zero.\"\"\"\n",
    "        return np.zeros(len(self))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Atom features all: [1.      0.      0.      0.      0.      0.      0.      1.      0.\n",
      " 1.      0.      0.      1.      0.      0.      0.      0.      0.\n",
      " 0.      1.      0.      0.      0.      1.      0.      0.12011]\n",
      "Atom features some: [1. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.\n",
      " 0. 0.]\n",
      "Atom features none: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "# Example usage\n",
    "atomic_nums = [6, 7, 8]\n",
    "degrees = [1, 2, 3]\n",
    "formal_charges = [-1, 0, 1]\n",
    "chiral_tags = [0, 1, 2]\n",
    "num_Hs = [0, 1, 2]\n",
    "hybridizations = [1, 2, 3]\n",
    "\n",
    "keep_features_all = [True] * 8\n",
    "keep_features_some = [True, True, False, True, False, True, True, False]\n",
    "keep_features_none = [False] * 8\n",
    "\n",
    "featurizer_all = CustomMultiHotAtomFeaturizer(\n",
    "    atomic_nums=atomic_nums,\n",
    "    degrees=degrees,\n",
    "    formal_charges=formal_charges,\n",
    "    chiral_tags=chiral_tags,\n",
    "    num_Hs=num_Hs,\n",
    "    hybridizations=hybridizations,\n",
    "    keep_features=keep_features_all\n",
    ")\n",
    "\n",
    "featurizer_some = CustomMultiHotAtomFeaturizer(\n",
    "    atomic_nums=atomic_nums,\n",
    "    degrees=degrees,\n",
    "    formal_charges=formal_charges,\n",
    "    chiral_tags=chiral_tags,\n",
    "    num_Hs=num_Hs,\n",
    "    hybridizations=hybridizations,\n",
    "    keep_features=keep_features_some\n",
    ")\n",
    "\n",
    "featurizer_none = CustomMultiHotAtomFeaturizer(\n",
    "    atomic_nums=atomic_nums,\n",
    "    degrees=degrees,\n",
    "    formal_charges=formal_charges,\n",
    "    chiral_tags=chiral_tags,\n",
    "    num_Hs=num_Hs,\n",
    "    hybridizations=hybridizations,\n",
    "    keep_features=keep_features_none\n",
    ")\n",
    "\n",
    "mol = Chem.MolFromSmiles('CCO')\n",
    "atom = mol.GetAtomWithIdx(0)  # Get the first atom\n",
    "\n",
    "features = featurizer_all(atom)\n",
    "print(\"Atom features all:\", features)\n",
    "\n",
    "features = featurizer_some(atom)\n",
    "print(\"Atom features some:\", features)\n",
    "\n",
    "features = featurizer_none(atom)\n",
    "print(\"Atom features none:\", features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CustomMultiHotBondFeaturizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomMultiHotBondFeaturizer(MultiHotBondFeaturizer):\n",
    "    \"\"\"A custom MultiHotBondFeaturizer that allows for selective feature ablation.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    keep_features : List[bool], optional\n",
    "        a list of booleans to indicate which bond features to keep except for nullity. If None, all features are kept. For any element that is False, the corresponding feature's encoding is set to all zeros. Useful for ablation and SHAP analysis.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,\n",
    "                 bond_types: Sequence[BondType] | None = None,\n",
    "                 stereos: Sequence[int] | None = None,\n",
    "                 keep_features: List[bool] = None):\n",
    "        super().__init__(bond_types, stereos)\n",
    "        \n",
    "        self._MultiHotBondFeaturizer__size = 1 + len(self.bond_types) + 2 + (len(self.stereo) + 1)\n",
    "\n",
    "        if keep_features is None:\n",
    "            keep_features = [True] * 4 \n",
    "        self.keep_features = keep_features        \n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self._MultiHotBondFeaturizer__size\n",
    "\n",
    "    def __call__(self, b: Bond) -> np.ndarray:\n",
    "        x = np.zeros(len(self), int)\n",
    "\n",
    "        if b is None:\n",
    "            x[0] = 1\n",
    "            return x\n",
    "        i = 1\n",
    "        bond_type = b.GetBondType()\n",
    "        bt_bit, size = self.one_hot_index(bond_type, self.bond_types)\n",
    "        if self.keep_features[0] and bt_bit != size:\n",
    "            x[i + bt_bit] = 1\n",
    "        i += size - 1\n",
    "\n",
    "        if self.keep_features[1]:\n",
    "            x[i] = int(b.GetIsConjugated())\n",
    "        if self.keep_features[2]:\n",
    "            x[i + 1] = int(b.IsInRing())\n",
    "        i += 2\n",
    "\n",
    "        if self.keep_features[3]:\n",
    "            stereo_bit, _ = self.one_hot_index(int(b.GetStereo()), self.stereo)\n",
    "            x[i + stereo_bit] = 1\n",
    "\n",
    "        return x\n",
    "\n",
    "    def zero_mask(self) -> np.ndarray:\n",
    "        \"\"\"Featurize the bond by setting all bits to zero.\"\"\"\n",
    "        return np.zeros(len(self), int)\n",
    "\n",
    "    @classmethod\n",
    "    def one_hot_index(cls, x, xs: Sequence) -> tuple[int, int]:\n",
    "        \"\"\"Returns a tuple of the index of ``x`` in ``xs`` and ``len(xs) + 1`` if ``x`` is in ``xs``.\n",
    "        Otherwise, returns a tuple with ``len(xs)`` and ``len(xs) + 1``.\"\"\"\n",
    "        n = len(xs)\n",
    "        return xs.index(x) if x in xs else n, n + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bond features all: [0 1 0 0 0 0 0 1 0 0 0 0 0 0]\n",
      "Bond features some: [0 1 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      "Bond features none: [0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "# Example usage\n",
    "bond_types = [BondType.SINGLE, BondType.DOUBLE, BondType.TRIPLE, BondType.AROMATIC]\n",
    "stereos = [0, 1, 2, 3, 4, 5]\n",
    "keep_features_all = [True] * 4\n",
    "keep_features_some = [True, False, True, False]\n",
    "keep_features_none = [False] * 4\n",
    "\n",
    "featurizer_all = CustomMultiHotBondFeaturizer(\n",
    "    bond_types=bond_types,\n",
    "    stereos=stereos,\n",
    "    keep_features=keep_features_all\n",
    ")\n",
    "\n",
    "featurizer_some = CustomMultiHotBondFeaturizer(\n",
    "    bond_types=bond_types,\n",
    "    stereos=stereos,\n",
    "    keep_features=keep_features_some\n",
    ")\n",
    "\n",
    "featurizer_none = CustomMultiHotBondFeaturizer(\n",
    "    bond_types=bond_types,\n",
    "    stereos=stereos,\n",
    "    keep_features=keep_features_none\n",
    ")\n",
    "\n",
    "mol = Chem.MolFromSmiles('CCO')\n",
    "bond = mol.GetBondWithIdx(0)  # Get the first bond\n",
    "\n",
    "features = featurizer_all(bond)\n",
    "print(\"Bond features all:\", features)\n",
    "\n",
    "features = featurizer_some(bond)\n",
    "print(\"Bond features some:\", features)\n",
    "\n",
    "features = featurizer_none(bond)\n",
    "print(\"Bond features none:\", features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CustomSimpleMoleculeMolGraphFeaturizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class CustomSimpleMoleculeMolGraphFeaturizer(SimpleMoleculeMolGraphFeaturizer):\n",
    "    \"\"\"A custom SimpleMoleculeMolGraphFeaturizer with additional feature control.\"\"\"\n",
    "    \n",
    "    keep_atom_features: Optional[List[bool]] = None\n",
    "    keep_bond_features: Optional[List[bool]] = None\n",
    "    keep_atoms: Optional[List[bool]] = None\n",
    "    keep_bonds: Optional[List[bool]] = None\n",
    "\n",
    "    def __post_init__(self, extra_atom_fdim: int = 0, extra_bond_fdim: int = 0):\n",
    "        super().__post_init__(extra_atom_fdim, extra_bond_fdim)\n",
    "\n",
    "        if isinstance(self.atom_featurizer, CustomMultiHotAtomFeaturizer) and self.keep_atom_features is not None:\n",
    "            self.atom_featurizer.keep_features = self.keep_atom_features\n",
    "        if isinstance(self.bond_featurizer, CustomMultiHotBondFeaturizer) and self.keep_bond_features is not None:\n",
    "            self.bond_featurizer.keep_features = self.keep_bond_features\n",
    "\n",
    "    def __call__(\n",
    "        self,\n",
    "        mol: Chem.Mol,\n",
    "        atom_features_extra: np.ndarray | None = None,\n",
    "        bond_features_extra: np.ndarray | None = None,\n",
    "    ) -> MolGraph:\n",
    "        n_atoms = mol.GetNumAtoms()\n",
    "        n_bonds = mol.GetNumBonds()\n",
    "\n",
    "        if self.keep_atoms is None:\n",
    "            self.keep_atoms = [True] * n_atoms\n",
    "        if self.keep_bonds is None:\n",
    "            self.keep_bonds = [True] * n_bonds\n",
    "\n",
    "        if atom_features_extra is not None and len(atom_features_extra) != n_atoms:\n",
    "            raise ValueError(\n",
    "                \"Input molecule must have same number of atoms as `len(atom_features_extra)`!\"\n",
    "                f\"got: {n_atoms} and {len(atom_features_extra)}, respectively\"\n",
    "            )\n",
    "        if bond_features_extra is not None and len(bond_features_extra) != n_bonds:\n",
    "            raise ValueError(\n",
    "                \"Input molecule must have same number of bonds as `len(bond_features_extra)`!\"\n",
    "                f\"got: {n_bonds} and {len(bond_features_extra)}, respectively\"\n",
    "            )\n",
    "        if n_atoms == 0:\n",
    "            V = np.zeros((1, self.atom_fdim), dtype=np.single)\n",
    "        else:\n",
    "            V = np.array([self.atom_featurizer(a) if self.keep_atoms[a.GetIdx()] else self.atom_featurizer.zero_mask()\n",
    "                          for a in mol.GetAtoms()], dtype=np.single)\n",
    "\n",
    "        if atom_features_extra is not None:\n",
    "            V = np.hstack((V, atom_features_extra))\n",
    "\n",
    "        E = np.empty((2 * n_bonds, self.bond_fdim))\n",
    "        edge_index = [[], []]\n",
    "\n",
    "        i = 0\n",
    "        for u in range(n_atoms):\n",
    "            for v in range(u + 1, n_atoms):\n",
    "                bond = mol.GetBondBetweenAtoms(u, v)\n",
    "                if bond is None:\n",
    "                    continue\n",
    "\n",
    "                x_e = self.bond_featurizer(bond) if self.keep_bonds[bond.GetIdx()] else self.bond_featurizer.zero_mask()\n",
    "\n",
    "                if bond_features_extra is not None:\n",
    "                    x_e = np.concatenate((x_e, bond_features_extra[bond.GetIdx()]), dtype=np.single)\n",
    "\n",
    "                E[i: i + 2] = x_e\n",
    "                edge_index[0].extend([u, v])\n",
    "                edge_index[1].extend([v, u])\n",
    "                i += 2\n",
    "\n",
    "        rev_edge_index = np.arange(len(E)).reshape(-1, 2)[:, ::-1].ravel()\n",
    "        edge_index = np.array(edge_index, int)\n",
    "        return MolGraph(V, E, edge_index, rev_edge_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Molecule graph: MolGraph(V=array([[1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "       [1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "       [0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0.,\n",
      "        0., 0., 0., 0., 0., 0., 0., 1., 0., 0.]], dtype=float32), E=array([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]), edge_index=array([[0, 1, 1, 2],\n",
      "       [1, 0, 2, 1]]), rev_edge_index=array([1, 0, 3, 2]))\n"
     ]
    }
   ],
   "source": [
    "# Example usage\n",
    "atom_featurizer = CustomMultiHotAtomFeaturizer(\n",
    "    atomic_nums=[6, 7, 8],\n",
    "    degrees=[1, 2, 3],\n",
    "    formal_charges=[-1, 0, 1],\n",
    "    chiral_tags=[0, 1, 2],\n",
    "    num_Hs=[0, 1, 2],\n",
    "    hybridizations=[1, 2, 3],\n",
    "    keep_features=[True, True, False, True, False, True, True, False]\n",
    ")\n",
    "\n",
    "bond_featurizer = CustomMultiHotBondFeaturizer(\n",
    "    bond_types=[BondType.SINGLE, BondType.DOUBLE, BondType.TRIPLE, BondType.AROMATIC],\n",
    "    stereos=[0, 1, 2, 3, 4, 5],\n",
    "    keep_features=[True, False, True, False]\n",
    ")\n",
    "\n",
    "featurizer = CustomSimpleMoleculeMolGraphFeaturizer(\n",
    "    atom_featurizer=atom_featurizer,\n",
    "    bond_featurizer=bond_featurizer,\n",
    "    keep_atom_features=[True, True, False, True, False, True, True, False],\n",
    "    keep_bond_features=[True, False, True, False],\n",
    ")\n",
    "\n",
    "# Example molecule (RDKit Mol object required)\n",
    "from rdkit import Chem\n",
    "mol = Chem.MolFromSmiles('CCO')\n",
    "\n",
    "mol_graph = featurizer(mol)\n",
    "print(\"Molecule graph:\", mol_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SHAP analysis to interpret Chemprop model prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: Shapley value analysis to explain importance of default chemprop atom and bond features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing molecule: Cn1c(CN2CCN(CC2)c3ccc(Cl)cc3)nc4ccccc14\n"
     ]
    }
   ],
   "source": [
    "chemprop_dir = Path.cwd().parent\n",
    "\n",
    "# load chemprop model checkpoint file\n",
    "checkpoint_path = chemprop_dir / \"tests\" / \"data\" / \"example_model_v2_regression_mol.ckpt\" \n",
    "mpnn = models.MPNN.load_from_checkpoint(checkpoint_path)\n",
    "\n",
    "# load data\n",
    "test_path = chemprop_dir / \"tests\" / \"data\" / \"regression\" / \"mol\" / \"mol.csv\"\n",
    "smiles_column = 'smiles'\n",
    "df_test = pd.read_csv(test_path)\n",
    "smis = df_test[smiles_column]\n",
    "test_data = [data.MoleculeDatapoint.from_smi(smi) for smi in smis]\n",
    "\n",
    "# pick a test molecule for demonstration \n",
    "test_mol = smis.iloc[0]\n",
    "print(f\"Testing molecule: {test_mol}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the featurizer\n",
    "atom_featurizer = CustomMultiHotAtomFeaturizer.v2() # chemprop v2 default atom featurizer settings\n",
    "bond_featurizer = CustomMultiHotBondFeaturizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A helper function to get predictions from a molecule with ability to keep or remove specific atom and bond features\n",
    "def get_predictions(keep_atom_features: Optional[List[bool]], keep_bond_features: Optional[List[bool]], mol: str) -> float:\n",
    "    featurizer = CustomSimpleMoleculeMolGraphFeaturizer(\n",
    "        atom_featurizer=atom_featurizer,\n",
    "        bond_featurizer=bond_featurizer,\n",
    "        keep_atom_features=keep_atom_features,\n",
    "        keep_bond_features=keep_bond_features\n",
    "    )\n",
    "    test_data = [data.MoleculeDatapoint.from_smi(mol)]\n",
    "    test_dset = data.MoleculeDataset(test_data, featurizer=featurizer)\n",
    "    test_loader = data.build_dataloader(test_dset, shuffle=False, batch_size=1)\n",
    "\n",
    "    with torch.inference_mode():\n",
    "        trainer = pl.Trainer(\n",
    "            logger=False,\n",
    "            enable_progress_bar=False,\n",
    "            accelerator=\"cpu\",\n",
    "            devices=1\n",
    "        )\n",
    "        test_preds = trainer.predict(mpnn, test_loader)\n",
    "    return test_preds[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/knathan/anaconda3/envs/chemprop_delete/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:425: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=11` in the `DataLoader` to improve performance.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction with keep_features set 0: tensor([2.2535])\n",
      "Prediction with keep_features set 1: tensor([2.2319])\n",
      "Prediction with keep_features set 2: tensor([2.1880])\n"
     ]
    }
   ],
   "source": [
    "# example prediction with different keep_atom_features and keep_bond_features\n",
    "\n",
    "# keep all atom and bond features\n",
    "keep_atom_features_0 = [True]*8\n",
    "keep_bond_features_0 = [True]*4\n",
    "\n",
    "# keep some atom and bond features\n",
    "keep_atom_features_1 = [True, True, False, True, True, False, True, True]\n",
    "keep_bond_features_1 = [True, True, False, True]\n",
    "\n",
    "# remove all atom and bond features\n",
    "keep_atom_features_2 = [False]*8\n",
    "keep_bond_features_2 = [False]*4\n",
    "\n",
    "pred_0 = get_predictions(keep_atom_features_0, keep_bond_features_0, test_mol)\n",
    "pred_1 = get_predictions(keep_atom_features_1, keep_bond_features_1, test_mol)\n",
    "pred_2 = get_predictions(keep_atom_features_2, keep_bond_features_2, test_mol)\n",
    "\n",
    "print(f\"Prediction with keep_features set 0: {pred_0}\") # expected 2.2535\n",
    "print(f\"Prediction with keep_features set 1: {pred_1}\") # expected 2.2319\n",
    "print(f\"Prediction with keep_features set 2: {pred_2}\") # expected 2.1880"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example wrapper class for use as the model input in SHAP explainer\n",
    "# The wrapper needs to be initialized first with the molecule to be explained, and then can be called with a boolean list representing the features to keep\n",
    "# The wrapper is needed because SHAP explainer requires a callable model with a single input argument, adapt X as needed\n",
    "class MoleculeModelWrapper:\n",
    "    def __init__(self, mol: str):\n",
    "        self.mol = mol\n",
    "    \n",
    "    def __call__(self, X):\n",
    "        preds = []\n",
    "        for keep_features in X:\n",
    "            try:\n",
    "                # unpacking X, indices corresponds to feature orders from default chemprop featurizer, adapt as needed\n",
    "                keep_atom_features = keep_features[:8] # 8 atom features\n",
    "                keep_bond_features = keep_features[8:] # 4 bond features\n",
    "            except:\n",
    "                print(f\"Invalid input: {keep_features}\")\n",
    "                raise\n",
    "            pred = get_predictions(keep_atom_features, keep_bond_features, self.mol)\n",
    "            preds.append([pred.item()])\n",
    "        return np.array(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example masker function for use with SHAP explainer\n",
    "# The masker function takes in a binary mask and the input data X, and returns the masked input data. This simulates the effect of masking out certain features.\n",
    "def binary_masker(binary_mask, x):\n",
    "    masked_x = deepcopy(x)\n",
    "    masked_x[binary_mask == 0] = 0\n",
    "    return np.array([masked_x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the model wrapper with the test molecule\n",
    "model_wrapper = MoleculeModelWrapper(test_mol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.25354147]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test the model wrapper with a random feature choice\n",
    "keep_features = [1] * 12  # 8 atom features + 4 bond features\n",
    "feature_choice = np.array([keep_features])\n",
    "model_wrapper(feature_choice) # expected 2.25354171"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the SHAP explainer with the model wrapper and masker\n",
    "explainer = shap.PermutationExplainer(model_wrapper, masker=binary_masker)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/knathan/anaconda3/envs/chemprop_delete/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:425: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=11` in the `DataLoader` to improve performance.\n",
      "PermutationExplainer explainer: 2it [00:28, 28.55s/it]               \n"
     ]
    }
   ],
   "source": [
    "# Compute SHAP values, using 100 evaluations of different feature choices (notice that feature choices are masked out randomly by the binary masker, so the results may vary between runs)\n",
    "explanation = explainer(feature_choice, max_evals=100) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ".values =\n",
       "array([[ 0.00123063,  0.01496077,  0.00213072, -0.01216608,  0.00954816,\n",
       "         0.00413817,  0.00643879, -0.00101143,  0.01162252,  0.00842983,\n",
       "         0.00846943,  0.01178101]])\n",
       "\n",
       ".base_values =\n",
       "array([[2.18796897]])\n",
       "\n",
       ".data =\n",
       "array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the SHAP values\n",
    "explanation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu0AAAKFCAYAAAB4GddQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnCFJREFUeJzs3Xt81NWd//HXJCSTe8KQkIQQMIJICWAKAgGWFlrkEha7KxBh44WIDVAiFQm43GugRmCpLQVsQBtuqwSCdbuSxp+CAmWCKFouBq1hEQ0XJZCLGBhCkt8fAwOTSSBAhhnC+/l4zIOZ8z3nez7fPHbre75z5oyhpqamBhERERERcVseri5ARERERESuTaFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1Nob0JqamooLy9HW++LiIiINC0K7U3I999/T3BwMN9//72rSxERERGRRqTQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5pq5ugBxghNn4OxFV1chIiIicuP8jRDs7+oq3I5Ce1OUugq+KXd1FSIiIiI3JqYlvDZJob0OCu1N0VfFUHjK1VWIiIiISCPRmnYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERJq+0h8g5RUIGwv+Y2DAXPjkcMPHHyqCIekQ8B9gegIe/wOcKnPs99scePhFCE8GwyPwmw2NUr5Cu4iIiIg0bdXVMGwBvL4TUofCoifguzLoPxe+PH798UXF8JPZUHgSXkyCtIdhy1546AW4UGnfd/br8FEh/DimUS/BaaE9JycHg8FQ7yM3N9dZUwMwffp0MjIynDpHYygpKWH8+PHEx8djMpkwGAx06dLF1WWJiIiI3Dn6z4Gxf6z/eE4+mL+A1akw71GYNBQ+SAdPD5iXff3zv7gZfjgP216AycNg5kjYOBX2fQWr37fve+RPcOLPsP7ZW7kiB07/RdQBAwaQkJDg0N61a1enzpuVlUVERAQzZsxw6jy36tixY6xcuZLg4GA6dOjA3r17XV2SiIiISNOSkw/hIfBI/JW2sGBI7APrd4ClEoxe9Y/fvBv+9UFoE3albeAD0KEVbDRDyqAr7fe0bPTy4TaE9ri4ONLS0pw9zW1lsViorKwkICDgls9177338vnnn3P//fcD4OPjc8vnFBEREZGrfHoEut0LHrUWmfS8D1a+C/88Dl3a1j322GnrUpoH2zke63kf5N6eG65usaZ96dKldOrUCR8fH4xGIx06dGD58uV19ouPjyc0NBQvLy8CAwPp06cPO3bssOtnMBgoLi7m4MGDdktyDh48aDs+ZMgQh/NnZGRgMBjIycmxtaWkpGAwGDCbzYwePRqTyYSvry95eXkAVFRUkJqaSnR0NF5eXvj5+dGrVy+2bdvWoGv38/OzBXYRERERcYITJRDZ3LH9ctvxM9cee3Xf2uPPnLXeqXcyp99pr6iooKioyK7N19eXFi1aAPDUU0+RlZVF9+7dmTx5Mp6enmzZsoXU1FROnDjBggULbOMyMzMJDg4mMTGRyMhICgsL2bx5M4MGDcJsNtOtWzcAFi9eTHp6OoGBgUyZMsU2vnXr1jd9HUlJSXh7ezNu3DgMBgNt27bFYrEQHx/PoUOHGDRoEMnJyZSWlpKdnc3QoUN5++23eeihh256ThERERGppfIilFU4tlkqobjcvt0UYL27fu4CGOuIvT7e1n/PXah/vsvH6lo+4+N1pc+1ltc0AqeH9szMTDIzM+3a+vfvz/vvv8/WrVvJysriySefZPXq1bbjGRkZ9OnThyVLljBlyhRbwN+1axchISF255o4cSL9+vVj/vz5/OUvfwEgLS2NhQsXYjKZGm1pTkBAAHv37sXb29vWNm3aNA4cOMC6det47LHHbO1z586lY8eOPPfccxw4cKBR5hcRERG5G1y4cAHvq16bzWb69Olje12w6k06TapjG0XzF7Dh7/ZtR/5EuckHf2MzPC0XHc953hrIC44U0oletuO7d++mR48eeHp6gq+1mh/OlOJ/6XhRURHV1dW0OW+9w15eeZ6vDx6hc+fOtnPs2bOHnte4jhvl9NA+fPhwxowZY9fWpk0bAF599VUMBgOTJk1yuBs/bNgw8vPzycvLIykpCcAW2Kurqzlz5gznz5+ndevWtGrViv379zv1Op555hm7wA7w5ptv0qpVK/r37+9Qf69evcjLy+P7778nMDDQqbWJiIiINBW181btoNtpTAJ0qLW0eOpqiGgO035h3x4RQpCPN0S1uLLM5epzXmrrNPBf7IbFx1/1hdVLy2L8y6/cjbet3jhRAqYAgsJa0Dmshd05evbsCayo9zpulNNDe/v27R1C+2WFhYXU1NRcuqi6HTt2zPZ827ZtzJgxg3379mGxWOz6hYWF1R7aqOrahrGoqIgLFy4QHR1d77hjx47RsWNHZ5YmIiIicvdoHmDduaV2W2Rzx/bL4u6BnYes+7Vf/WXUD78EP6N1F5j6RLWAsCD4uI4fYtrzJcQ17n7s9XF6aL+WmpoaDAYDa9eutX78UIfLgf7QoUMkJCTg5+fH+PHjiY2NJSAgAIPBwPPPP8+5c+duuZ6LFy/We6yuu+U1NTW0adOGl156qd5xt7KOXkREREQawcje1m0f39wNIy/d8S4uh01mGP6g/Xr0wyet/7aLuNI2ojeseR++KYboUGvb1v3WXWemDL8tl+DS0B4TE8PevXtp3769/ccQdVi9ejUWi4V169YxatQou2MTJ07Ey8t+8b/BYKj3XP7+/pSWljq0Hz58Az9lC0RGRlJWVkZiYmK9bzpERERExMVG9ob4DpC8DAqKIDQQVuRBVTW8MNq+78/nWf/96qrvZM4cYQ34A+bCr4fB2fOw+H+s20Qm/8x+/LoP4OgpqLi0KmRHASzYZH3++E+h7c3t4+7SLR+ffvppAKZOnUplpeNWOUeOHLE9vxyKa2pq7Pqkp6dTVlbmMNbHx4fy8nKHdoCoqCgKCgrsjp88eZK33nrrhuofMWIEZWVlTJs2rc7jV9cvIiIiIi7i6Qm5s+HRvrB0C0xbC6FB1l84vT/q+uOjQ2H7fOvd9/9cD4vegoRu8O48x11jXtsKc96AjDetr98/aH095w048t1NX4JL77QPHjyYlJQUVq5cSbt27UhISCAqKorjx4+zb98+9uzZY1uykpiYyJIlS5gwYQI7d+7EZDJhNpvJz88nPDycqqoqu3N37dqV3Nxcxo0bR2xsLB4eHowdO5aQkBBSUlJIS0ujR48ejBo1ipKSEjZu3Eh4eHidbwDqk5GRwfbt23n55ZfZuXMn/fr1Izg4mKNHj7Jr1y6MRmODviA7c+ZM253/qqoqvv32W371q18B0L17d8aNG9fgmkRERETuOh/Mv36f5gHw6iTr41q+yqy7PbYNvDO3cWq5CS4N7WDdEjI+Pp5ly5axfv16LBYLQUFBxMTEMGvWLFu/uLg4NmzYwKxZs1i1ahUeHh507tyZd955hwkTJnDy5Em78y5fvpykpCSys7OpqKigpqaGgQMHEhISwtSpUykqKmLdunUsXLiQli1b8uyzz+Lh4cHMmTMbXLvRaCQ/P5958+axadMm2w9CmUwmYmNjSU5ObtB5Vq1aRXFxse31qVOneOWVVwDrGxuFdhEREZG7m6Gm9noTuWOVl5cTHBxMWfsUggpPubocERERkRtzf5R1yUork6srcTsuXdMuIiIiIiLXp9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibs7l+7SLE9wTCp7erq5CRERE5MbEtHR1BW5Lob0pWvZLCAxydRUiIiIiN87f6OoK3JJCe1MUaYIghXYRERGRpkJr2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxc81cXYA4wYkzcPaiq6sQERFxP/5GCPZ3dRUiN0yhvSlKXQXflLu6ChEREfcS0xJem6TQLnckhfam6KtiKDzl6ipEREREpJFoTbuIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIicqtKf4CUVyBsLPiPgQFz4ZPDDR9/qAiGpEPAf4DpCXj8D3CqzLHfb3Pg4RchPBkMj8BvNjTaJYh7U2gXERERuRXV1TBsAby+E1KHwqIn4Lsy6D8Xvjx+/fFFxfCT2VB4El5MgrSHYcteeOgFuFBp33f26/BRIfw4xjnXIm7LaaE9JycHg8FQ7yM3N9dZUwMwffp0MjIynDpHY8jNzaVfv35ERETg4+ODj48Pbdq0Yfz48Zw6pR9IEhERcbn+c2DsH+s/npMP5i9gdSrMexQmDYUP0sHTA+ZlX//8L26GH87Dthdg8jCYORI2ToV9X8Hq9+37HvkTnPgzrH/2Vq5I7kBO/0XUAQMGkJCQ4NDetWtXp86blZVFREQEM2bMcOo8t+rgwYOcP3+e4cOHExUVRXV1NR999BGvvfYaf/vb3/jss88IDAx0dZkiIiJSn5x8CA+BR+KvtIUFQ2IfWL8DLJVg9Kp//Obd8K8PQpuwK20DH4AOrWCjGVIGXWm/p2Wjly93BqeH9ri4ONLS0pw9zW1lsViorKwkICDgls81ffp0pk+f7tA+ZcoUfv/735OVlcXkyZNveR4RERFxkk+PQLd7waPWAoae98HKd+Gfx6FL27rHHjttXUrzYDvHYz3vg9y9jV+v3JHcYk370qVL6dSpEz4+PhiNRjp06MDy5cvr7BcfH09oaCheXl4EBgbSp08fduzYYdfPYDBQXFzMwYMH7ZbkHDx40HZ8yJAhDufPyMjAYDCQk5Nja0tJScFgMGA2mxk9ejQmkwlfX1/y8vIAqKioIDU1lejoaLy8vPDz86NXr15s27btlv4mMTHWtWpnzpy5pfOIiIiIk50ogcjmju2X245f47/lJ0rs+9Yef+as9U693PWcfqe9oqKCoqIiuzZfX19atGgBwFNPPUVWVhbdu3dn8uTJeHp6smXLFlJTUzlx4gQLFiywjcvMzCQ4OJjExEQiIyMpLCxk8+bNDBo0CLPZTLdu3QBYvHgx6enpBAYGMmXKFNv41q1b3/R1JCUl4e3tzbhx4zAYDLRt2xaLxUJ8fDyHDh1i0KBBJCcnU1paSnZ2NkOHDuXtt9/moYceatD5y8vLKS8v5/vvv2f79u0sWLCAZs2a8W//9m83XbOIiIjcoMqLUFbh2GaphOJy+3ZTgPXu+rkLYKwjUvl4W/89d6H++S4fq2v5jI/XlT7XWl4jdwWn32nPzMwkOjra7jFy5EgAtm7dSlZWFk8++SQff/wxixYtIiMjg/3799O7d2+WLFnC6dOnbefatWsXZrOZFStWMGfOHNasWcN7771HVVUV8+fPt/VLS0vDaDRiMplIS0uzPUJCQm76OgICAjhw4ACLFy9m0aJF9OjRg9mzZ3PgwAGysrLYsmUL6enpLF261LYO/bnnnmvw+SdMmEB0dDSdOnVi4sSJ+Pj4sHr1auLi4m66ZhEREbFXXV3NP//5T7s2s9l85cWuz63bNl79MH8BG/7u2P51sfWcPs04e7rUdory8nLrp/vnLwVyX2/7Oa6e09ca7As/+5yqqirb8YKCAs6Xfm/rU1RUxNdff207/v333ztcW71zXLJ7926HOUpKSmyva89huw7N4ZQ5bpTT77QPHz6cMWPG2LW1adMGgFdffRWDwcCkSZMc7sYPGzaM/Px88vLySEpKArCF7urqas6cOcP58+dp3bo1rVq1Yv/+/U69jmeeeQZvb2+7tjfffJNWrVrRv39/h/p79epFXl4e33//fYO+SJqWlsbw4cM5c+YMf//739mzZw/ffvtto16DiIjI3c7Dw4MOHTrYtfXp0+fKiwfugXfn2Q+auhoimsO0X9i3R4RYz9mqBQHfX1nCEhQUROfOneHD96wNrUz0qbWm3TbnpWUx7f1N4OlpO96pUycoedd6N9/o5bBaoK5sYXcddbyOj4+3e92pUye717XnsF2H5nDKHDfK6aG9ffv2DqH9ssLCQmpqaujZs2e9448dO2Z7vm3bNmbMmMG+ffuwWCx2/cLCwmoPbVRdunRxaCsqKuLChQtER0fXO+7YsWN07Njxuufv1q2bbXnPpEmTWL9+PY8//jgGg8FuiY+IiIg4UfMA684ttdsimzu2XxZ3D+w8ZN2v/eovo374JfgZrbvA1CeqBYQFwcd1/BDTni8hTvuxi5XTQ/u11NTUYDAYWLt2LZ5Xvbu82uVAf+jQIRISEvDz82P8+PHExsYSEBCAwWDg+eef59y5c7dcz8WLF+s9Vtc72pqaGtq0acNLL71U77ibXUf/2GOPkZqayquvvqrQLiIi4s5G9rZu+/jmbhh56W5qcTlsMsPwB+3Xox8+af23XcSVthG9Yc378E0xRIda27but+46M2X47bkGcXsuDe0xMTHs3buX9u3bO3wMUdvq1auxWCysW7eOUaNG2R2bOHEiXl72X9AwGAz1nsvf35/S0lKH9sOHb+DnhoHIyEjKyspITEys903Hrbhw4QLl5eXX7ygiIiKuM7I3xHeA5GVQUAShgbAiD6qq4YXR9n1/fmnpzVeZV9pmjrAG/AFz4dfD4Ox5WPw/1m0ik39mP37dB3D0FFRcWnGwowAWbLI+f/yn0Fb7uDdVLt3y8emnnwZg6tSpVFY6bmd05MgR2/PLobimpsauT3p6OmVlZQ5jfXx86g28UVFRFBQU2B0/efIkb7311g3VP2LECMrKypg2bVqdx6+uvz7/93//V2f7woULOXfunNN/hEpERERukacn5M6GR/vC0i0wbS2EBll/4fT+qOuPjw6F7fOtd9//cz0segsSulnX1tfeNea1rTDnDch40/r6/YPW13PegCPfNfqliftw6Z32wYMHk5KSwsqVK2nXrh0JCQlERUVx/Phx9u3bx549e2xLVhITE1myZAkTJkxg586dmEwmzGYz+fn5hIeH233DF6y/uJqbm8u4ceOIjY3Fw8ODsWPHEhISQkpKCmlpafTo0YNRo0ZRUlLCxo0bCQ8Pr/MNQH0yMjLYvn07L7/8Mjt37qRfv34EBwdz9OhRdu3ahdFovO4XZAcOHEhwcDDdu3enbdu2lJaWsnv3bvLz8zGZTCxZsuTG/7AiIiLSeD6Yf/0+zQPg1UnWx7VcfYf9arFt4J25jVOLNEkuDe1g3RIyPj6eZcuWsX79eiwWC0FBQcTExDBr1ixbv7i4ODZs2MCsWbNYtWoVHh4edO7cmXfeeYcJEyZw8uRJu/MuX76cpKQksrOzqaiooKamhoEDBxISEsLUqVMpKipi3bp1LFy4kJYtW/Lss8/i4eHBzJkzG1y70WgkPz+fefPmsWnTJtsPQplMJmJjY0lOTr7uOR577DH++te/snnzZr7//ns8PT2JiIjg8ccf58UXXyQqqgHv0EVERESkSTPU1F5vInes8vJygoODKWufQlDhKVeXIyIi4l7uj7IuWWllcnUlIjfMpWvaRURERETk+hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM25fJ92cYJ7QsHT29VViIiIuJeYlq6uQOSmKbQ3Rct+CYFBrq5CRETE/fgbXV2ByE1RaG+KIk0QpNAuIiIi0lRoTbuIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibq6ZqwsQJzhxBs5edHUVIiIizuFvhGB/V1chclsptDdFqavgm3JXVyEiItL4YlrCa5MU2uWuo9DeFH1VDIWnXF2FiIiIiDQSrWkXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5hTaRURERC4r/QFSXoGwseA/BgbMhU8ON3z8oSIYkg4B/wGmJ+DxP8CpMsd+v82Bh1+E8GQwPAK/2dBolyBNk0K7iIiICEB1NQxbAK/vhNShsOgJ+K4M+s+FL49ff3xRMfxkNhSehBeTIO1h2LIXHnoBLlTa9539OnxUCD+Occ61SJNzQ6E9JycHg8FQ7yM3N9dZdQIwffp0MjIynDpHYygpKWH8+PHEx8djMpkwGAx06dKl3v5Lly5l6NCh3HPPPXh6emIwGDh48OBtrFhEROQu0H8OjP1j/cdz8sH8BaxOhXmPwqSh8EE6eHrAvOzrn//FzfDDedj2AkweBjNHwsapsO8rWP2+fd8jf4ITf4b1z97KFcld5KZ+EXXAgAEkJCQ4tHft2vWWC7qWrKwsIiIimDFjhlPnuVXHjh1j5cqVBAcH06FDB/bu3XvN/qtWreKLL74gJiaGiIgIjh9vwLt5ERERaVw5+RAeAo/EX2kLC4bEPrB+B1gqwehV//jNu+FfH4Q2YVfaBj4AHVrBRjOkDLrSfk/LRi9fmrabCu1xcXGkpaU1di0uZbFYqKysJCAg4JbPde+99/L5559z//33A+Dj43PN/hs3bqRdu3Z4e3szYsQI3nzzzVuuQURERG7Qp0eg273gUWshQs/7YOW78M/j0KVt3WOPnbYupXmwneOxnvdB7rVv4Ilcj9PWtC9dupROnTrh4+OD0WikQ4cOLF++vM5+8fHxhIaG4uXlRWBgIH369GHHjh12/QwGA8XFxRw8eNBuSc7lZSQGg4EhQ4Y4nD8jIwODwUBOTo6tLSUlBYPBgNlsZvTo0ZhMJnx9fcnLywOgoqKC1NRUoqOj8fLyws/Pj169erFt27YGXbufn58tsDfEj370I7y9vRvcX0RERJzgRAlENndsv9x2/My1x17dt/b4M2etd+pFbtJN3WmvqKigqKjIrs3X15cWLVoA8NRTT5GVlUX37t2ZPHkynp6ebNmyhdTUVE6cOMGCBQts4zIzMwkODiYxMZHIyEgKCwvZvHkzgwYNwmw2061bNwAWL15Meno6gYGBTJkyxTa+devWN3MJACQlJeHt7c24ceMwGAy0bdsWi8VCfHw8hw4dYtCgQSQnJ1NaWkp2djZDhw7l7bff5qGHHrrpOUVEROQ2qLwIZRWObZZKKC63bzcFWO+un7sAxjqikc+lG2vnLtQ/3+VjdS2f8fG60uday2tEruGm7rRnZmYSHR1t9xg5ciQAW7duJSsriyeffJKPP/6YRYsWkZGRwf79++nduzdLlizh9OnTtnPt2rULs9nMihUrmDNnDmvWrOG9996jqqqK+fPn2/qlpaVhNBoxmUykpaXZHiEhITd98QEBARw4cIDFixezaNEievTowezZszlw4ABZWVls2bKF9PR0li5dymeffUZgYCDPPffcTc8nIiIijWv37t1UVVXZXhcUFFBSUgK7Prdu23j1w/wFbPi7Q/vev7xjHezrDZaLmM1muzk+/8f+K8evnuOSoqIiTpZdugtvqaS8vNx+Q4nzlXbjAYc5ioqK6r6Oq45//fXXttcOc9Rxztqv6/1baQ6XzHGjbupO+/DhwxkzZoxdW5s2bQB49dVXMRgMTJo0yeFu/LBhw8jPzycvL4+kpCQAW+iurq7mzJkznD9/ntatW9OqVSv2799/M+U12DPPPOOwLOXNN9+kVatW9O/f36H+Xr16kZeXx/fff09gYKBTaxMREZHri4+Pt3vdqVMn65MHvODdefadp66GiOYw7Rd2zd3/5UfWJ5HN4UQJffr0sTveMTjc+qSVyX6OS1q3bg0GX+uLEyUEBQXRuXPnKx1OlFjv5l91l732HK1btwZPT8fruPr4VRzmqOOctV/X+7fSHC6Z40bdVGhv3769Q2i/rLCwkJqaGnr27Fnv+GPHjtmeb9u2jRkzZrBv3z4sFotdv7CwsNpDG1Vd2zAWFRVx4cIFoqOj6x137NgxOnbs6MzSRERE5FY0D7Du3FK7LbK5Y/tlcffAzkPW/dqv/jLqh1+Cn9G6C0x9olpAWBB8XMcPMe35EuK0H7vcmpsK7ddSU1ODwWBg7dq1eF71jvFqlwP9oUOHSEhIwM/Pj/HjxxMbG0tAQAAGg4Hnn3+ec+fO3XI9Fy9erPdYXXfLa2pqaNOmDS+99FK9425lHb2IiIi4qZG9rds+vrkbRl66K1pcDpvMMPxB+/Xoh09a/20XcaVtRG9Y8z58UwzRoda2rfutu85MGX57rkGarEYP7TExMezdu5f27ds7fLRQ2+rVq7FYLKxbt45Ro0bZHZs4cSJeXvZf1jAYDPWey9/fn9LSUof2w4dv4KeHgcjISMrKykhMTKz3TYeIiIg0QSN7Q3wHSF4GBUUQGggr8qCqGl4Ybd/355eW3nyVeaVt5ghrwB8wF349DM6eh8X/Y90mMvln9uPXfQBHT0HFpVUGOwpgwSbr88d/Cm21j7vYa/QtH59++mkApk6dSmWl49ZGR44csT2/HIpramrs+qSnp1NWVuYw1sfHh/Lycod2gKioKAoKCuyOnzx5krfeeuuG6h8xYgRlZWVMmzatzuNX1y8iIiJNiKcn5M6GR/vC0i0wbS2EBll/4fT+qOuPjw6F7fOtd9//cz0segsSulnX1tfeNea1rTDnDci49Nss7x+0vp7zBhz5rtEvTe58jX6nffDgwaSkpLBy5UratWtHQkICUVFRHD9+nH379rFnzx7bkpXExESWLFnChAkT2LlzJyaTCbPZTH5+PuHh4Xbf2gXrL67m5uYybtw4YmNj8fDwYOzYsYSEhJCSkkJaWho9evRg1KhRlJSUsHHjRsLDw+t8A1CfjIwMtm/fzssvv8zOnTvp168fwcHBHD16lF27dmE0Ghv0BdmZM2fa7vxXVVXx7bff8qtf/QqA7t27M27cOFvfv/zlL7z77rsAtm8ev/jii7Yv6a5YsaLB9YuIiEg9Pph//T7NA+DVSdbHtVx9h/1qsW3gnbmNU4vIVRo9tIN1S8j4+HiWLVvG+vXrsVgsBAUFERMTw6xZs2z94uLi2LBhA7NmzWLVqlV4eHjQuXNn3nnnHSZMmMDJkyftzrt8+XKSkpLIzs6moqKCmpoaBg4cSEhICFOnTqWoqIh169axcOFCWrZsybPPPouHhwczZ85scO1Go5H8/HzmzZvHpk2bbD8IZTKZiI2NJTk5uUHnWbVqFcXFxbbXp06d4pVXXgGsb2yuDu1/+9vfWLVqld34N954w/ZcoV1ERETk7maoqb02Re5Y5eXlBAcHU9Y+haDCU64uR0REpPHdH2VdrnJp+0WRu0Wjr2kXEREREZHGpdAuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibs4p+7SLi90TCp7erq5CRESk8cW0dHUFIi6h0N4ULfslBAa5ugoRERHn8De6ugKR206hvSmKNEGQQruIiIhIU6E17SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzSm0i4iIiIi4uWauLkCc4MQZOHvR1VWIiIjcGn8jBPu7ugoRt6DQ3hSlroJvyl1dhYiIyM2LaQmvTVJoF7lEob0p+qoYCk+5ugoRERERaSRa0y4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIjI3af0B0h5BcLGgv8YGDAXPjnc8PGHimBIOgT8B5iegMf/AKfKHPv9NgcefhHCk8HwCPxmQ6NdgtxdFNpFRETk7lJdDcMWwOs7IXUoLHoCviuD/nPhy+PXH19UDD+ZDYUn4cUkSHsYtuyFh16AC5X2fWe/Dh8Vwo9jnHMtctdwWmjPycnBYDDU+8jNzXXW1ABMnz6djIwMp87RWIqKinjssceIiorCaDQSEhLCAw88wMqVK11dmoiIyJ2n/xwY+8f6j+fkg/kLWJ0K8x6FSUPhg3Tw9IB52dc//4ub4YfzsO0FmDwMZo6EjVNh31ew+n37vkf+BCf+DOufvZUrEnH+L6IOGDCAhIQEh/auXbs6dd6srCwiIiKYMWOGU+e5VeXl5fTo0YPTp0/zi1/8gq5du3L69GlycnIYP348RUVFpKenu7pMERGRpiMnH8JD4JH4K21hwZDYB9bvAEslGL3qH795N/zrg9Am7ErbwAegQyvYaIaUQVfa72nZ6OXL3cnpoT0uLo60tDRnT3NbWSwWKisrCQgIuOVzvfbaa5w8eZLp06ezcOFCW/uMGTNo27Yt69atU2gXERFpTJ8egW73gketBQc974OV78I/j0OXtnWPPXbaupTmwXaOx3reB7l7G79eEdxkTfvSpUvp1KkTPj4+GI1GOnTowPLly+vsFx8fT2hoKF5eXgQGBtKnTx927Nhh189gMFBcXMzBgwftluQcPHjQdnzIkCEO58/IyMBgMJCTk2NrS0lJwWAwYDabGT16NCaTCV9fX/Ly8gCoqKggNTWV6OhovLy88PPzo1evXmzbtq1B115WZv3SSnR0tF17WFgYRqMRHx+fBp1HREREGuhECUQ2d2y/3Hb8zLXHXt239vgzZ6136kUamdPvtFdUVFBUVGTX5uvrS4sWLQB46qmnyMrKonv37kyePBlPT0+2bNlCamoqJ06cYMGCBbZxmZmZBAcHk5iYSGRkJIWFhWzevJlBgwZhNpvp1q0bAIsXLyY9PZ3AwECmTJliG9+6deubvo6kpCS8vb0ZN24cBoOBtm3bYrFYiI+P59ChQwwaNIjk5GRKS0vJzs5m6NChvP322zz00EPXPO/DDz/M/PnzWbBgAQEBAfTu3ZtTp07x29/+loqKCp5//vmbrllERKTJq7wIZRWObZZKKC63bzcFWO+un7sAxjoikI+39d9zF+qf7/KxupbP+Hhd6XOt5TUiN8Hpd9ozMzOJjo62e4wcORKArVu3kpWVxZNPPsnHH3/MokWLyMjIYP/+/fTu3ZslS5Zw+vRp27l27dqF2WxmxYoVzJkzhzVr1vDee+9RVVXF/Pnzbf3S0tIwGo2YTCbS0tJsj5CQkJu+joCAAA4cOMDixYtZtGgRPXr0YPbs2Rw4cICsrCy2bNlCeno6S5cu5bPPPiMwMJDnnnvuuuft1q0by5Yto7KykuTkZDp27Ei/fv3Iz89n8+bNjB079qZrFhERudN9+umndq/NZrPd64JVb1q3bbz6Yf4CNvzdsf3rYsrLy6kyNgPLRcdznrcG8oIjhXZz7N69m6qqKusLX2uw/+FMqe14UVERX3/9NZy33mEvrzxv+3T/sj179lzzOuzmAAoKCigpKXGc45Ly8nKHOWqfU3O49xw3yul32ocPH86YMWPs2tq0aQPAq6++isFgYNKkSQ5344cNG0Z+fj55eXkkJSUB2EJ3dXU1Z86c4fz587Ru3ZpWrVqxf/9+p17HM888g7e3t13bm2++SatWrejfv79D/b169SIvL4/vv/+ewMDAa567RYsWtGvXjpEjR9K9e3e++eYbVq5cSVJSEm+//TY//elPG/16RERE7gQ//vGP7V736dPH7nWnMQnQ4X77QVNXQ0RzmPYL+/aIEIJ8vCGqxZVlLlef81Jbp4H/YjcsPv6qL6xeWhbjX37lbrztk/wTJWAKICisBZ3DWtido2fPnsCKeq/Dbg6gU6dOdq9rrxYICgqic+fOdm21z6k53HuOG+X00N6+fXuH0H5ZYWEhNTU1l/4PuW7Hjh2zPd+2bRszZsxg3759WCwWu35hYWG1hzaqLl26OLQVFRVx4cIFh/XoVzt27BgdO3as9/j69et54oknWLNmDY8//ritPTk5mc6dOzNx4kQKCgpurXgREZGmqnmAdeeW2m2RzR3bL4u7B3Yesu7XfvWXUT/8EvyM1l1g6hPVAsKC4OM6fohpz5cQp/3YxTmcHtqvpaamBoPBwNq1a/H09Kyzz+VAf+jQIRISEvDz82P8+PHExsYSEBCAwWDg+eef59y5c7dcz8WLF+s9Vtfd8pqaGtq0acNLL71U77jrraNfvHgxRqPRLrAD3HvvvXTp0oWPP/6Yc+fO4evre53qRUREpEFG9rZu+/jmbhh56e5ncTlsMsPwB+3Xox8+af23XcSVthG9Yc378E0xRIda27but+46M2X47bkGueu4NLTHxMSwd+9e2rdv7/AxRG2rV6/GYrGwbt06Ro0aZXds4sSJeHnZf+HDYDDUey5/f39KS0sd2g8fvoGfLwYiIyMpKysjMTGx3jcd13Pq1Clqamqorq7Go9bWU1VVVVRXV9utqRIREZFbNLI3xHeA5GVQUAShgbAiD6qq4YXR9n1/Ps/671eZV9pmjrAG/AFz4dfD4Ox5WPw/1m0ik39mP37dB3D0FFRcWiGwowAWbLI+f/yn0Fb7uEvDuHTLx6effhqAqVOnUlnpuD3SkSNHbM8vh+Kamhq7Punp6bZtE6/m4+NDeXm5QztAVFQUBQUFdsdPnjzJW2+9dUP1jxgxgrKyMqZNm1bn8avrr09MTAwWi4Vly5bZte/fv58DBw7Qpk2bRtkPXkRERC7x9ITc2fBoX1i6BaathdAg6y+c3h91/fHRobB9vvXu+3+uh0VvQUI3eHee464xr22FOW9AxpvW1+8ftL6e8wYc+a7RL02aLpfeaR88eDApKSmsXLmSdu3akZCQQFRUFMePH2ffvn3s2bPHtmQlMTGRJUuWMGHCBHbu3InJZMJsNpOfn094eLjD3eiuXbuSm5vLuHHjiI2NxcPDg7FjxxISEkJKSgppaWn06NGDUaNGUVJSwsaNGwkPD6/zDUB9MjIy2L59Oy+//DI7d+6kX79+BAcHc/ToUXbt2oXRaLzuF2Tnzp3L8OHDee6553j//feJi4vjm2++YePGjVRWVjJv3rwb/8OKiIjczT6Yf/0+zQPg1UnWx7VcfYf9arFt4J25jVOLSAO4NLSDdUvI+Ph4li1bxvr167FYLAQFBRETE8OsWbNs/eLi4tiwYQOzZs1i1apVeHh40LlzZ9555x0mTJjAyZMn7c67fPlykpKSyM7OpqKigpqaGgYOHEhISAhTp06lqKiIdevWsXDhQlq2bMmzzz6Lh4cHM2fObHDtRqOR/Px85s2bx6ZNm2w/CGUymYiNjSU5Ofm65xg8eDB5eXnMmzePbdu28de//hUfHx86duzIjBkzbNtjioiIiMjdy1BTe72J3LHKy8sJDg6mrH0KQYWnXF2OiIjIzbs/yrpcpZXJ1ZWIuAWXrmkXEREREZHrU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmXb/koTnBPKHh6u7oKERGRmxejXwoVuZpCe1O07JcQGOTqKkRERG6Nv9HVFYi4DYX2pijSBEEK7SIiIiJNhda0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNxcM1cXIE5w4gycvejqKkRE5DJ/IwT7u7oKEbmDKbQ3Ramr4JtyV1chIiIAMS3htUkK7SJySxTam6KviqHwlKurEBEREZFGojXtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERO5kpT9AyisQNhb8x8CAufDJ4YaPP1QEQ9Ih4D/A9AQ8/gc4VebY77c58PCLEJ4MhkfgNxsa7RJE5PoU2kVERO5U1dUwbAG8vhNSh8KiJ+C7Mug/F748fv3xRcXwk9lQeBJeTIK0h2HLXnjoBbhQad939uvwUSH8OMY51yIi1+S00J6Tk4PBYKj3kZub66ypAZg+fToZGRlOncMZDh8+jL+/PwaDgeeee87V5YiIiCv1nwNj/1j/8Zx8MH8Bq1Nh3qMwaSh8kA6eHjAv+/rnf3Ez/HAetr0Ak4fBzJGwcSrs+wpWv2/f98if4MSfYf2zt3JFInKTnP7jSgMGDCAhIcGhvWvXrk6dNysri4iICGbMmOHUeRrb2LFjqaqqcnUZIiJyJ8jJh/AQeCT+SltYMCT2gfU7wFIJRq/6x2/eDf/6ILQJu9I28AHo0Ao2miFl0JX2e1o2evki0nBOD+1xcXGkpaU5e5rbymKxUFlZSUBAQKOed9WqVezatYtf//rX/P73v2/Uc4uISBP06RHodi941PrgvOd9sPJd+Odx6NK27rHHTluX0jzYzvFYz/sgd2/j1ysiN80t1rQvXbqUTp064ePjg9FopEOHDixfvrzOfvHx8YSGhuLl5UVgYCB9+vRhx44ddv0MBgPFxcUcPHjQbknOwYMHbceHDBnicP6MjAwMBgM5OTm2tpSUFAwGA2azmdGjR2MymfD19SUvLw+AiooKUlNTiY6OxsvLCz8/P3r16sW2bdtu6G9w+vRp/vM//5N///d/p2/fvjc0VkRE7lInSiCyuWP75bbjZ6499uq+tcefOWu9Uy8ibsHpd9orKiooKiqya/P19aVFixYAPPXUU2RlZdG9e3cmT56Mp6cnW7ZsITU1lRMnTrBgwQLbuMzMTIKDg0lMTCQyMpLCwkI2b97MoEGDMJvNdOvWDYDFixeTnp5OYGAgU6ZMsY1v3br1TV9HUlIS3t7ejBs3DoPBQNu2bbFYLMTHx3Po0CEGDRpEcnIypaWlZGdnM3ToUN5++20eeuihBp0/JSWF6upq/vSnP7F9+/abrlNERO5QlRehrMKxzVIJxeX27aYA6931cxfAWMd/yn28rf+eu1D/fJeP1bV8xsfrSp9rLa8RkdvG6aE9MzOTzMxMu7b+/fvz/vvvs3XrVrKysnjyySdZvXq17XhGRgZ9+vRhyZIlTJkyxRbwd+3aRUhIiN25Jk6cSL9+/Zg/fz5/+ctfAEhLS2PhwoWYTKZGW5oTEBDA3r178fb2trVNmzaNAwcOsG7dOh577DFb+9y5c+nYsSPPPfccBw4cuO65c3Nz+ctf/sLvf/97wsLCrttfRESaoF2fW7drrM38BWz4u33bkT9Z15j7eoPlouOY85cCua+347HLLh+r6276+crrjxeR28rpy2OGDx/O66+/bve4fPf81VdfxWAwMGnSJIqKiuwew4YN4/z587ZlKIAtsFdXV1NcXExRURGtW7emVatW7N+/36nX8cwzz9gFdoA333yTVq1a0b9/f7vaz58/T69evSgoKOD777+/5nktFgsTJkzgxz/+MZMnT3bmJYiIiItUVtoHY7PZ7Pj6gXvg3Xnw7jwK/pBIVd4c6NoWBsVx9NWxfP/mVNvxoos/8PXXX1uXsZwooby83LYEFLiy9KWVqd459x4/Yte3oKCAkpISW1tViB9ff3vC1t9hjvqu4yq7d++221zBbg6gqKjIeh2aQ3PchXPcKENNTU3NLZ2hHjk5OYwaNYopU6bwu9/9rs4+PXr04OOPP77meRYuXMj06dMB2LZtGzNmzGDfvn1YLBa7fmFhYXz33Xd2ryMiIuq8020wGBg8eLDdGwKw3uGfOXMmmzZtYuTIkYB12cqqVaswm8307t3brr/RaOTChWt89AgcOnSIjh071nv8V7/6Fa+++ip79uwhLi4OaNjfri7l5eUEBwdT1j6FoMJTDR4nIiJOdH+UdUvFqwJ0g/WfY72jvvqZuo+PWgw7D8HxV+2/jJryCvz3Djiz9trLW1qOhf6dYWOtT6XvT4XWLWDrC45jisutP+Q0LxF+M/pGr0hEbpLTl8dcS01NDQaDgbVr1+Lp6Vlnn549ewLW8JuQkICfnx/jx48nNjaWgIAADAYDzz//POfOnbvlei5erOMjxksCAwPrrL9Nmza89NJL9Y671jr6w4cP8+qrrzJ06FBqamr49NNPATh69Chg/XLqp59+SkxMjMOyIBEREUb2tm77+OZuGNnH2lZcDpvMMPxB+8B++KT133YRV9pG9IY178M3xRAdam3but+668yU4bfnGkSkQVwa2mNiYti7dy/t27cnPj7+mn1Xr16NxWJh3bp1jBo1yu7YxIkT8fKyv5NgMBjqPZe/vz+lpaUO7YcP38DPPgORkZGUlZWRmJhY75uOa/n666+prKzkr3/9K3/9618djq9du5a1a9eybNkyJk2adMPnFxGRJm5kb4jvAMnLoKAIQgNhRR5UVcMLte6C/3ye9d+vrvqe2cwR1oA/YC78ehicPQ+L/8e6TWTyz+zHr/sAjp6CikufdO8ogAWbrM8f/ym01T7uIs7k0tD+9NNPk5OTw9SpU/nggw8cgveRI0eIibH+XPLlUFx7NU96ejplZWWEhobatfv4+FBeXuvb9pdERUVRUFBAeXk5QUFBAJw8eZK33nrrhuofMWIEL7/8MtOmTatzGcvV9delc+fOLFu2zKF9//79rFy5kkGDBvHwww8zaNCgOkaLiMhdz9MTcmfDtDWwdIt1t5ce7a3Lae6Puv746FDYPh+eWw3/uR68m8Gw7rBkrOOymte2wvbPrrx+/6D1AfAvP1JoF3Eyl4b2wYMHk5KSwsqVK2nXrh0JCQlERUVx/Phx9u3bx549e2xLVhITE1myZAkTJkxg586dmEwmzGYz+fn5hIeHO/yKaNeuXcnNzWXcuHHExsbi4eHB2LFjCQkJISUlhbS0NHr06MGoUaMoKSlh48aNhIeHU1ZW1uD6MzIy2L59Oy+//DI7d+6kX79+BAcHc/ToUXbt2oXRaLzmF2TDwsLqvIOek5PDypUriY2N1R12EZG72Qfzr9+neQC8Osn6uJavMutuj20D79Sxa83N1CIiTuPS0A7WLSHj4+NZtmwZ69evx2KxEBQURExMDLNmzbL1i4uLY8OGDcyaNYtVq1bh4eFB586deeedd5gwYQInT560O+/y5ctJSkoiOzubiooKampqGDhwICEhIUydOpWioiLWrVvHwoULadmyJc8++yweHh7MnDmzwbUbjUby8/OZN28emzZtsv0glMlkIjY2luTk5Mb5I4mIiIjIXc1pu8fI7afdY0RE3NCt7B4jInKJ0/dpFxERERGRW6PQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm7O5fu0ixPcEwqe3q6uQkREAGL0S6EicusU2puiZb+EwCBXVyEiIpf5G11dgYjc4RTam6JIEwQptIuIiIg0FVrTLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzzVxdgDjBiTNw9qKrqxARuX38jRDs7+oqREScRqG9KUpdBd+Uu7oKEZHbI6YlvDZJoV1EmjSF9qboq2IoPOXqKkRERESkkWhNu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYREZH6lP4AKa9A2FjwHwMD5sInhxs+/lARDEmHgP8A0xPw+B/gVJljv9/mwMMvQngyGB6B32xotEsQkaZBoV1ERKQu1dUwbAG8vhNSh8KiJ+C7Mug/F748fv3xRcXwk9lQeBJeTIK0h2HLXnjoBbhQad939uvwUSH8OMY51yIid7wbCu05OTkYDIZ6H7m5uc6qE4Dp06eTkZHh1DkaQ0lJCePHjyc+Ph6TyYTBYKBLly7XHLN69Wo6duyI0WgkICCAn/zkJ+zfv/82VSwichfqPwfG/rH+4zn5YP4CVqfCvEdh0lD4IB08PWBe9vXP/+Jm+OE8bHsBJg+DmSNh41TY9xWsft++75E/wYk/w/pnb+WKRKQJu6kfVxowYAAJCQkO7V27dr3lgq4lKyuLiIgIZsyY4dR5btWxY8dYuXIlwcHBdOjQgb17916z/yuvvMKkSZNo27Yt06dPp7S0lLVr1/LTn/6Ujz76iPbt29+mykVExCYnH8JD4JH4K21hwZDYB9bvAEslGL3qH795N/zrg9Am7ErbwAegQyvYaIaUQVfa72nZ6OWLSNNyU6E9Li6OtLS0xq7FpSwWC5WVlQQEBNzyue69914+//xz7r//fgB8fHyuOe+sWbMwmUx88sknNG/eHIBHHnmEn//850yZMoX//d//veWaRETkBn16BLrdCx61PpTueR+sfBf+eRy6tK177LHT1qU0D7ZzPNbzPsi99s0cEZHanLamfenSpXTq1AkfHx+MRiMdOnRg+fLldfaLj48nNDQULy8vAgMD6dOnDzt27LDrZzAYKC4u5uDBg3ZLcg4ePGg7PmTIEIfzZ2RkYDAYyMnJsbWlpKRgMBgwm82MHj0ak8mEr68veXl5AFRUVJCamkp0dDReXl74+fnRq1cvtm3b1qBr9/PzswX263nzzTcpKSlh1KhRtsAO1k8zunTpwtatW7FYLA06l4iINKITJRDZ3LH9ctvxM9cee3Xf2uPPnLXeqRcRaaCbutNeUVFBUVGRXZuvry8tWrQA4KmnniIrK4vu3bszefJkPD092bJlC6mpqZw4cYIFCxbYxmVmZhIcHExiYiKRkZEUFhayefNmBg0ahNlsplu3bgAsXryY9PR0AgMDmTJlim1869atb+YSAEhKSsLb25tx48ZhMBho27YtFouF+Ph4Dh06xKBBg0hOTqa0tJTs7GyGDh3K22+/zUMPPXTTc9ZmNpsB+MlPfuJwrFu3buzfv5+9e/fSp0+fRptTROSuU3kRyioc2yyVUFxu324KsN5dP3cBjHX8Z9LH2/rvuQv1z3f5WF3LZ3y8rvS51vIaEZGr3FRoz8zMJDMz066tf//+vP/++2zdupWsrCyefPJJVq9ebTuekZFBnz59WLJkCVOmTLEF/F27dhESEmJ3rokTJ9KvXz/mz5/PX/7yFwDS0tJYuHAhJpOp0ZbmBAQEsHfvXry9vW1t06ZN48CBA6xbt47HHnvM1j537lw6duzIc889x4EDBxplfoATJ04AEBPjuGPA5TckR44cUWgXEbkVuz63btdYm/kL2PB3+7Yjf7KuMff1BstFxzHnLwVyX2/HY5ddPlbX3fTzldcfLyJSy00tjxk+fDivv/663ePy3fNXX30Vg8HApEmTKCoqsnsMGzaM8+fP25ahALbAXl1dTXFxMUVFRbRu3ZpWrVo5ffeUZ555xi6wg3W5SqtWrejfv79d7efPn6dXr14UFBTw/fffN1oN586dA6yfVNR2eS38Dz/80GjziYg0Zbt376aqqsr2uqCggJKSEnjgHnh3Hqden8S3/z0R3p0HXdty8WedObLySevrS4/8I59bB0c2hxMltk9ELzv890vr0VuZ7Oe4pKioiGPVl+7qnyihvLzctpTzcltlkI/dXfbacxQVFdV9HVcd//rrr22vHeao45y1X9f7t9IcmkNz3JY5bpShpqampqGdc3JyGDVqFFOmTOF3v/tdnX169OjBxx9/fM3zLFy4kOnTpwOwbds2ZsyYwb59+xzWboeFhfHdd9/ZvY6IiKjzTrfBYGDw4MF2bwjAeod/5syZbNq0iZEjRwLWNe2rVq3CbDbTu3dvu/5Go5ELF67xkSdw6NAhOnbseM0+V/Px8eG+++6rs+6RI0eyefNm8vPziY+Ptzs2Z84cFixYwPr160lKSrruPOXl5QQHB1PWPoWgwlMNrk9E5I52f5R1W8VLIbrB+s+x3lFf/Uzdx0cthp2H4Pir9l9GTXkF/nsHnFl77eUtLcdC/86wsdanw/enQusWsPUFxzHF5dYfcpqXCL8ZfWPXIyJN2k0tj7mWmpoaDAYDa9euxdPTs84+PXv2BKzhNyEhAT8/P8aPH09sbCwBAQEYDAaef/55213oW3HxYh0fbV4SGBhYZ/1t2rThpZdeqnfcrayjry0yMhKwLoGpHdovf2+grqUzIiLiZCN7W7d9fHM3jLy0RLG4HDaZYfiD9oH98Enrv+0irrSN6A1r3odviiE61Nq2db9115kpw2/PNYhIk9HooT0mJoa9e/fSvn17hxBa2+rVq7FYLKxbt45Ro0bZHZs4cSJeXvZ3MAwGQ73n8vf3p7S01KH98OEb+LlprCG6rKyMxMTEet90NKY+ffqwbNkyduzYwZgxY+yOffLJJ/j6+tK9e3en1yEiIrWM7A3xHSB5GRQUQWggrMiDqmp4odZd8J/Ps/771VXf95o5whrwB8yFXw+Ds+dh8f9Yt4lM/pn9+HUfwNFTUHHpE+cdBbBgk/X54z+FttrHXeRu1+hbPj799NMATJ06lcpKxy/gHDlyxPb8ciiuvUInPT2dsrIyh7E+Pj6Ul5c7tANERUVRUFBgd/zkyZO89dZbN1T/iBEjKCsrY9q0aXUev7r+xvDII48QEhLCpk2b7NZKbd++nQMHDjBgwACMRmOjzikiIg3g6Qm5s+HRvrB0C0xbC6FB1qU490ddf3x0KGyfb737/p/rYdFbkNDNuna+9rKa17bCnDcg403r6/cPWl/PeQOOfOdwahG5+zT6nfbBgweTkpLCypUradeuHQkJCURFRXH8+HH27dvHnj17bEtWEhMTWbJkCRMmTGDnzp2YTCbMZjP5+fmEh4fbfQEArL+4mpuby7hx44iNjcXDw4OxY8cSEhJCSkoKaWlp9OjRg1GjRlFSUsLGjRsJDw+v8w1AfTIyMti+fTsvv/wyO3fupF+/fgQHB3P06FF27dqF0Whs0BdkZ86cabvzX1VVxbfffsuvfvUrALp37864ceMA6xr6+fPnM3nyZLp168Zjjz1GWVkZa9asISgoiN///vcNrl1ERG7AB/Ov36d5ALw6yfq4lq8y626PbQPv1LFrzc3UIiJ3tUYP7WDdEjI+Pp5ly5axfv16LBYLQUFBxMTEMGvWLFu/uLg4NmzYwKxZs1i1ahUeHh507tyZd955hwkTJnDy5Em78y5fvpykpCSys7OpqKigpqaGgQMHEhISwtSpUykqKmLdunUsXLiQli1b8uyzz+Lh4cHMmTMbXLvRaCQ/P5958+axadMm2w9CmUwmYmNjSU5ObtB5Vq1aRXFxse31qVOneOWVVwDrG5vLoR0gNTUVPz8/Fi5cyKJFi2jWrBndunXjj3/8I/fdd1+DaxcRERGRpumGdo8R96bdY0TkrnSzu8eIiNxBGn1Nu4iIiIiINC6FdhERERERN6fQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzTtmnXVzsnlDw9HZ1FSIit0dMS1dXICLidArtTdGyX0JgkKurEBG5ffyNrq5ARMSpFNqbokgTBCm0i4iIiDQVWtMuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXPNXF2AOMGJM3D2oqurEBFxPn8jBPu7ugoREadTaG+KUlfBN+WurkJExLliWsJrkxTaReSuoNDeFH1VDIWnXF2FiIiIiDQSrWkXEREREXFzCu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiUpfSHyDlFQgbC/5jYMBc+ORww8cfKoIh6RDwH2B6Ah7/A5wqc+z32xx4+EUITwbDI/CbDY12CSLSdCi0i4iI1FZdDcMWwOs7IXUoLHoCviuD/nPhy+PXH19UDD+ZDYUn4cUkSHsYtuyFh16AC5X2fWe/Dh8Vwo9jnHMtItIkOC205+TkYDAY6n3k5uY6a2oApk+fTkZGhlPnaCz/+Mc/GDhwIMHBwXh5eREREcEvf/lLzp496+rSRESapv5zYOwf6z+ekw/mL2B1Ksx7FCYNhQ/SwdMD5mVf//wvboYfzsO2F2DyMJg5EjZOhX1fwer37fse+ROc+DOsf/ZWrkhEmjin/7jSgAEDSEhIcGjv2rWrU+fNysoiIiKCGTNmOHWeW7Vnzx4GDBhAVVUViYmJ3HvvvezevZvXXnuNTz75hI8++ggPD30gIiJyW+XkQ3gIPBJ/pS0sGBL7wPodYKkEo1f94zfvhn99ENqEXWkb+AB0aAUbzZAy6Er7PS0bvXwRaXqcHtrj4uJIS0tz9jS3lcViobKykoCAgFs+17PPPsu5c+f4n//5H4YPH25rf+aZZ1i2bBm/+93vmtzfT0TE7X16BLrdC7VvmvS8D1a+C/88Dl3a1j322GnrUpoH2zke63kf5O5t/HpFpMlzi1u4S5cupVOnTvj4+GA0GunQoQPLly+vs198fDyhoaF4eXkRGBhInz592LFjh10/g8FAcXExBw8etFuSc/DgQdvxIUOGOJw/IyMDg8FATk6OrS0lJQWDwYDZbGb06NGYTCZ8fX3Jy8sDoKKigtTUVKKjo/Hy8sLPz49evXqxbdu2Bl37P/7xDyIjI+0CO1jDPMC6desadB4REWlEJ0ogsrlj++W242euPfbqvrXHnzlrvVMvInIDnH6nvaKigqKiIrs2X19fWrRoAcBTTz1FVlYW3bt3Z/LkyXh6erJlyxZSU1M5ceIECxYssI3LzMwkODiYxMREIiMjKSwsZPPmzQwaNAiz2Uy3bt0AWLx4Menp6QQGBjJlyhTb+NatW9/0dSQlJeHt7c24ceMwGAy0bdsWi8VCfHw8hw4dYtCgQSQnJ1NaWkp2djZDhw7l7bff5qGHHrrmeSsrKzEajQ7tQUFBAHzxxRdUV1driYyIyM2qvAhlFY5tlkooLrdvNwVY766fuwDGOv4T6eNt/ffchfrnu3ysruUzPl5X+lxreY2ISC1OT4KZmZlER0fbPUaOHAnA1q1bycrK4sknn+Tjjz9m0aJFZGRksH//fnr37s2SJUs4ffq07Vy7du3CbDazYsUK5syZw5o1a3jvvfeoqqpi/vz5tn5paWkYjUZMJhNpaWm2R0hIyE1fR0BAAAcOHGDx4sUsWrSIHj16MHv2bA4cOEBWVhZbtmwhPT2dpUuX8tlnnxEYGMhzzz133fO2adOGoqIi/u///s+u/S9/+QtgXYpz8uTJm65bRKQpu3DBPjzv3r2bqqoq2+uCggK+z/vIum3j1Q/zF7Dh747tXxdjNpvB1xssFwGsry87b52vyruZ3RwlJSW219+Wl1qfXLqbXl5ebvukl/PWtvx/2C+RsZujnuu4eo6ioiK+/vpr22u7Oeo5p+bQHJrDvea4UYaampqaWzpDPXJychg1ahTDhw9nzJgxdsfatGlD3759GTNmDNnZ2Xz44YdERkba9VmzZg2zZ89m/fr1JCUl2R2rrq7mzJkznD9/HoC+ffvSrFkzDh++sn9uWFgYERERHDhwwKE2g8HA4MGDbUtcLsvIyGDmzJls2rTJ9sYiJSWFVatWkZmZSUpKil3/du3acf78eT788EOHOcaPH09eXh6lpaUEBgbW+3f63e9+x9SpU7nvvvvIyMigY8eObN26lblz53L27Fmqqqr4/PPPuf/+++s9x2Xl5eUEBwdT1j6FoMJT1+0vInJHuz/KujtLK9O1+5Wchb219lefuhoimsO0X9i3/8uPrHfT75sE90VC7mz746+9B0+vgP0vX3tNe+tfwsLHYfq/2x97/A/WNe2n1zqOKy63vnGYlwi/GX3taxKRu47Tl8e0b9/eIbRfVlhYSE1NDT179qx3/LFjx2zPt23bxowZM9i3bx8Wi8WuX1hYWO2hjapLly4ObUVFRVy4cIHo6Oh6xx07doyOHTvWe/y5557j1KlT/OEPf7C9UWjWrBlPPfUU27Zto7Cw0LaUSEREbkLzAOvOLbXbIps7tl8Wdw/sPGTdr/3q5Ykffgl+RusuMPWJagFhQfBxHT/EtOdLiNN+7CJy45we2q+lpqYGg8HA2rVr8fT0rLPP5UB/6NAhEhIS8PPzY/z48cTGxhIQEIDBYOD555/n3Llzt1zPxYsX6z1W193ympoa2rRpw0svvVTvuIaso8/IyGDOnDns2rWLc+fO0atXL8LDwwkKCiIkJITQ0NCGXYCIiDSOkb2t2z6+uRtG9rG2FZfDJjMMf9B+PfrhS0sY20VcaRvRG9a8D98UQ/Sl/w3fut+668wU+40HREQawqWhPSYmhr1799K+fXvi4+Ov2Xf16tVYLBbWrVvHqFGj7I5NnDgRLy/7L/QYDIZ6z+Xv709paalD+9XLaxoiMjKSsrIyEhMT633T0VB+fn52X1p99913+f777+vc415ERJxsZG+I7wDJy6CgCEIDYUUeVFXDC7WWrvx8nvXfrzKvtM0cYQ34A+bCr4fB2fOw+H+sS2qSf2Y/ft0HcPQUVFz6BHlHASzYZH3++E+hrfZxFxEXb/n49NNPAzB16lQqKx23vzpy5Ijt+eVQXHsJfnp6OmVlZQ5jfXx8KC8vd2gHiIqKoqCgwO74yZMneeutt26o/hEjRlBWVsa0adPqPH51/Tfi7Nmz/PrXv6ZZs2bMmzfvps4hIiK3wNPTup790b6wdAtMWwuhQdY19PdHXX98dChsn2+9+/6f62HRW5DQDd6d57hrzGtbYc4bkPGm9fX7B62v57wBR75r9EsTkTuTS++0Dx48mJSUFFauXEm7du1ISEggKiqK48ePs2/fPvbs2WNbspKYmMiSJUuYMGECO3fuxGQyYTabyc/PJzw83O4bvmD9xdXc3FzGjRtHbGwsHh4ejB07lpCQEFJSUkhLS6NHjx6MGjWKkpISNm7cSHh4eJ1vAOqTkZHB9u3befnll9m5cyf9+vUjODiYo0ePsmvXLoxGI/v377/mOcxmM0888QQ///nPiY6O5uTJk7z55pt8++23ZGRkXHO9v4iI3KQP5l+/T/MAeHWS9XEtV99hv1psG3hnbuPUIiJ3PZeGdrBuCRkfH8+yZctYv349FouFoKAgYmJimDVrlq1fXFwcGzZsYNasWaxatQoPDw86d+7MO++8w4QJExy2RVy+fDlJSUlkZ2dTUVFBTU0NAwcOJCQkhKlTp1JUVMS6detYuHAhLVu25Nlnn8XDw4OZM2c2uHaj0Uh+fj7z5s1j06ZNth+EMplMxMbGkpycfN1zREZGEh4ezqZNmygvL8fPz4+uXbvy5z//uc4fgBIRERGRu4/TtnyU209bPorIXaWhWz6KiDQB+plNERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibs7l+7SLE9wTCp7erq5CRMS5Ylq6ugIRkdtGob0pWvZLCAxydRUiIs7nb3R1BSIit4VCe1MUaYIghXYRERGRpkJr2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJurpmrCxAnOHEGzl50dRUicrP8jRDs7+oqRETEjSi0N0Wpq+CbcldXISI3I6YlvDZJoV1EROwotDdFXxVD4SlXVyEiIiIijURr2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiNxNSn+AlFcgbCz4j4EBc+GTww0ff6gIhqRDwH+A6Ql4/A9wqsyx329z4OEXITwZDI/AbzY02iWIiNyNFNpFRO4W1dUwbAG8vhNSh8KiJ+C7Mug/F748fv3xRcXwk9lQeBJeTIK0h2HLXnjoBbhQad939uvwUSH8OMY51yIicpdxWmjPycnBYDDU+8jNzXXW1ABMnz6djIwMp87RmL744guGDx9OaGgoXl5ehISE8OCDD5Kfn+/q0kTkTtF/Doz9Y/3Hc/LB/AWsToV5j8KkofBBOnh6wLzs65//xc3ww3nY9gJMHgYzR8LGqbDvK1j9vn3fI3+CE3+G9c/eyhWJiMglTv9xpQEDBpCQkODQ3rVrV6fOm5WVRUREBDNmzHDqPI1h27ZtPPzww/j6+vLII4/Qtm1bTp8+zaeffsrx4w24+yUi0hA5+RAeAo/EX2kLC4bEPrB+B1gqwehV//jNu+FfH4Q2YVfaBj4AHVrBRjOkDLrSfk/LRi9fRORu5vTQHhcXR1pamrOnua0sFguVlZUEBATc8rnOnj1LUlISYWFhfPTRR4SGhjZChSIidfj0CHS7Fzxqfcja8z5Y+S788zh0aVv32GOnrUtpHmzneKznfZC7t/HrFRERG7dY07506VI6deqEj48PRqORDh06sHz58jr7xcfH25aQBAYG0qdPH3bs2GHXz2AwUFxczMGDB+2W5Bw8eNB2fMiQIQ7nz8jIwGAwkJOTY2tLSUnBYDBgNpsZPXo0JpMJX19f8vLyAKioqCA1NZXo6Gi8vLzw8/OjV69ebNu2rUHXvmLFCk6ePMns2bMJDQ2loqKCioqKBv/tREQa7EQJRDZ3bL/cdvzMtcde3bf2+DNnrXfqRUTEKZx+p72iooKioiK7Nl9fX1q0aAHAU089RVZWFt27d2fy5Ml4enqyZcsWUlNTOXHiBAsWLLCNy8zMJDg4mMTERCIjIyksLGTz5s0MGjQIs9lMt27dAFi8eDHp6ekEBgYyZcoU2/jWrVvf9HUkJSXh7e3NuHHjMBgMtG3bFovFQnx8PIcOHWLQoEEkJydTWlpKdnY2Q4cO5e233+ahhx665nn/9re/AdCiRQtiY2M5dOgQNTU13HPPPcyfP5/HHnvspmsWkSas8iKUVTi2WSqhuNy+3RRgvbt+7gIY6/iffR9v67/nLtQ/3+VjdS2f8fG60uday2tEROSmOf1Oe2ZmJtHR0XaPkSNHArB161aysrJ48skn+fjjj1m0aBEZGRns37+f3r17s2TJEk6fPm07165duzCbzaxYsYI5c+awZs0a3nvvPaqqqpg/f76tX1paGkajEZPJRFpamu0REhJy09cREBDAgQMHWLx4MYsWLaJHjx7Mnj2bAwcOkJWVxZYtW0hPT2fp0qV89tlnBAYG8txzz133vF999RUATzzxBAEBAfz+979n7ty5lJeX88QTT/DGG2/cdM0icme6cME+PO/evZuqqirb64KCAr7P+8i6bePVD/MXsOHvju1fF2M2m8HXGywXAayvLztvna/Ku5ndHCUlJbbX35aXWp9cupteXl5u+/SS89a2/H/YL5Gxm6Oe67h6jqKiIr7++mvba7s56jmn5tAcmkNz3Klz3ChDTU1NzS2doR45OTmMGjWK4cOHM2bMGLtjbdq0oW/fvowZM4bs7Gw+/PBDIiMj7fqsWbOG2bNns379epKSkuyOVVdXc+bMGc6fPw9A3759adasGYcPX9lrOCwsjIiICA4cOOBQm8FgYPDgwbYlLpdlZGQwc+ZMNm3aZHtjkZKSwqpVq8jMzCQlJcWuf7t27Th//jwffvihwxzjx48nLy+P0tJSAgMD6/07RURE8O2339KpUycOHDiAx6W1pp988gk9evSgXbt2/POf/6x3/NXKy8sJDg6mrH0KQYWnGjRGRNzM/VHW3Vlama7dr+Qs7K21v/rU1RDRHKb9wr79X35kvZt+3yS4LxJyZ9sff+09eHoF7H/52mvaW/8SFj4O0//d/tjjf7CuaT+91nFccbn1jcO8RPjN6Gtfk4iI1Mvpy2Pat2/vENovKywspKamhp49e9Y7/tixY7bn27ZtY8aMGezbtw+LxWLXLywsrPbQRtWlSxeHtqKiIi5cuEB0dHS9444dO0bHjh3rPe7tbf1YevTo0bbADtCtWzd+9KMfUVBQQGlp6S19SiAiTVDzAOvOLbXbIps7tl8Wdw/sPGTdr/3qL6N++CX4Ga27wNQnqgWEBcHHdfwQ054vIU77sYuIOJPTQ/u11NTUYDAYWLt2LZ6ennX2uRzoDx06REJCAn5+fowfP57Y2FgCAgIwGAw8//zznDt37pbruXjxYr3H6rpbXlNTQ5s2bXjppZfqHXe9dfQtW7bkm2++ISoqyuFYWFgYNTU1FBcXK7SLyK0b2du67eObu2FkH2tbcTlsMsPwB+3Xox8+af23XcSVthG9Yc378E0xRF/a6WrrfuuuM1OG355rEBG5S7k0tMfExLB3717at29PfHz8NfuuXr0ai8XCunXrGDVqlN2xiRMn4uVl/+Ung8FQ77n8/f0pLS11aL96eU1DREZGUlZWRmJiYr1vOq7nxz/+MXv37uXo0aMOx7799ls8PDyIiIioY6SIyA0a2RviO0DyMigogtBAWJEHVdXwQq2lKz+fZ/33q8wrbTNHWAP+gLnw62Fw9jws/h/rkprkn9mPX/cBHD0FFZc+Fd1RAAs2WZ8//lNoq33cRURuhEu3fHz66acBmDp1KpWVjluFHTlyxPb8ciiuvQQ/PT2dsrIyh7E+Pj6Ul5c7tANERUVRUFBgd/zkyZO89dZbN1T/iBEjKCsrY9q0aXUev7r++qSkpODh4cF///d/2335bPv27Xz++ec88MADjbIfvIgInp7W9eyP9oWlW2DaWggNsq6hv9/x0z4H0aGwfb717vt/rodFb0FCN3h3nuOuMa9thTlvQMab1tfvH7S+nvMGHPmu0S9NRKSpc+md9sGDB5OSksLKlStp164dCQkJREVFcfz4cfbt28eePXtsS1YSExNZsmQJEyZMYOfOnZhMJsxmM/n5+YSHh9t9wxesv7iam5vLuHHjiI2NxcPDg7FjxxISEkJKSgppaWn06NGDUaNGUVJSwsaNGwkPD6/zDUB9MjIy2L59Oy+//DI7d+6kX79+BAcHc/ToUXbt2oXRaGT//v3XPEePHj14/PHHWbNmDQ888AD/9m//xpkzZ/jv//5vvL29+f3vf3/Df1cRuUt9MP/6fZoHwKuTrI9rufoO+9Vi28A7cxunFhERaTCXhnawbgkZHx/PsmXLWL9+PRaLhaCgIGJiYpg1a5atX1xcHBs2bGDWrFmsWrUKDw8POnfuzDvvvMOECRM4efKk3XmXL19OUlIS2dnZVFRUUFNTw8CBAwkJCWHq1KkUFRWxbt06Fi5cSMuWLXn22Wfx8PBg5syZDa7daDSSn5/PvHnz2LRpk+0HoUwmE7GxsSQnJzfoPKtXryYmJoasrCz+67/+C29vb3784x+zaNEi+vTp0+B6RERERKRpctqWj3L7actHkSagoVs+iojIXcWla9pFREREROT6FNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXURERETEzbl8n3ZxgntCwdPb1VWIyM2IaenqCkRExA0ptDdFy34JgUGurkJEbpa/0dUViIiIm1Fob4oiTRCk0C4iIiLSVGhNu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJurpmrCxAnOHEGzl50dRVyN/A3QrC/q6sQERFp8hTam6LUVfBNuaurkKYupiW8NkmhXURE5DZQaG+KviqGwlOurkJEREREGonWtIuIiIiIuDmFdhERERERN6fQLiIiIiLi5hTaRURERETcnEK7iIiIiIibU2gXEREREXFzCu0i4n5Kf4CUVyBsLPiPgQFz4ZPDrq5KRETEZRTaRcS9VFfDsAXw+k5IHQqLnoDvyqD/XPjyuKurExERcQmnhfacnBwMBkO9j9zcXGdNDcD06dPJyMhw6hyN4eDBg/X+jdq0aePq8kQaX/85MPaP9R/PyQfzF7A6FeY9CpOGwgfp4OkB87JvX50iIiJuxOm/iDpgwAASEhIc2rt27erUebOysoiIiGDGjBlOnaex9O3bl3/7t3+zazOZTK4pRsSVcvIhPAQeib/SFhYMiX1g/Q6wVILRy2XliYiIuILTQ3tcXBxpaWnOnua2slgsVFZWEhAQ0Gjn7NSpU5P7O4nclE+PQLd7waPWB4E974OV78I/j0OXtq6pTURExEXcYk370qVL6dSpEz4+PhiNRjp06MDy5cvr7BcfH09oaCheXl4EBgbSp08fduzYYdfPYDBQXFzssPTk4MGDtuNDhgxxOH9GRgYGg4GcnBxbW0pKCgaDAbPZzOjRozGZTPj6+pKXlwdARUUFqampREdH4+XlhZ+fH7169WLbtm03/Hc4e/Ys5eXlNzxOpEk5UQKRzR3bL7cdP3N76xEREXEDTr/TXlFRQVFRkV2br68vLVq0AOCpp54iKyuL7t27M3nyZDw9PdmyZQupqamcOHGCBQsW2MZlZmYSHBxMYmIikZGRFBYWsnnzZgYNGoTZbKZbt24ALF68mPT0dAIDA5kyZYptfOvWrW/6OpKSkvD29mbcuHEYDAbatm2LxWIhPj6eQ4cOMWjQIJKTkyktLSU7O5uhQ4fy9ttv89BDDzXo/GvXruXVV1+lpqYGk8nEv//7v7N06VL8/PxuumYRl6u8CGUVjm2WSiiu9QbVFGC9u37uAhjr+J8mH2/rv+cuOKdWERERN+b0O+2ZmZlER0fbPUaOHAnA1q1bycrK4sknn+Tjjz9m0aJFZGRksH//fnr37s2SJUs4ffq07Vy7du3CbDazYsUK5syZw5o1a3jvvfeoqqpi/vz5tn5paWkYjUZMJhNpaWm2R0hIyE1fR0BAAAcOHGDx4sUsWrSIHj16MHv2bA4cOEBWVhZbtmwhPT2dpUuX8tlnnxEYGMhzzz133fN6enrStWtXpkyZQmZmJvPnz+eee+7htddeo2/fvlRWVt50zSK3S3l5ue2TrMvMZjPs+ty6bePVD/MXsOHvDu1fbs2npKQEfL3BcpGioiK+/vpr2/kqzpRan/h6289Re86r7N69m6qqKtvrgoIC6xyX1J6j3uvQHJpDc2gOzaE5GnmOG2WoqampuaUz1CMnJ4dRo0YxfPhwxowZY3esTZs29O3blzFjxpCdnc2HH35IZGSkXZ81a9Ywe/Zs1q9fT1JSkt2x6upqzpw5w/nz5wHrlzibNWvG4cNX9nEOCwsjIiKCAwcOONRmMBgYPHiwbYnLZRkZGcycOZNNmzbZ3likpKSwatUqMjMzSUlJsevfrl07zp8/z4cffugwx/jx48nLy6O0tJTAwMDr/bkcDB8+nLfffpv/+q//YurUqQ0aU15eTnBwMGXtUwgqPHXDc4rckPujYNsL0OoaX5guOQt7a+2vPnU1RDSHab+wb/+XH1nvpt83Ce6LhNzZ9sdfew+eXgH7X9aadhERues4fXlM+/btHUL7ZYWFhdTU1NCzZ896xx87dsz2fNu2bcyYMYN9+/ZhsVjs+oWFhTVOwfXo0qWLQ1tRUREXLlwgOjq63nHHjh2jY8eONzzfSy+9xNtvv82WLVsaHNpF3E7zABj4gGNbZHPH9svi7oGdh6z7tV/9ZdQPvwQ/I3Ro5bRyRURE3JXTQ/u11NTUYDAYWLt2LZ6ennX2uRzoDx06REJCAn5+fowfP57Y2FgCAgIwGAw8//zznDt37pbruXjxYr3H6rpbXlNTQ5s2bXjppZfqHXez6+g7duyIh4cHpaWlNzVe5I41srd128c3d8PIPta24nLYZIbhD2q7RxERuSu5NLTHxMSwd+9e2rdvT3x8/DX7rl69GovFwrp16xg1apTdsYkTJ+LlZf8fcoPBUO+5/P396wzDVy+vaYjIyEjKyspITEys903Hzdq/fz/V1dW2L+yK3DVG9ob4DpC8DAqKIDQQVuRBVTW8MNrV1YmIiLiES7d8fPrppwGYOnVqnV+4PHLkiO355VBcewl+eno6ZWVlDmN9fHzq3T4xKiqKgoICu+MnT57krbfeuqH6R4wYQVlZGdOmTavz+NX11+fq5T+XVVVV2b7EOnz48BuqSeSO5+lpXc/+aF9YugWmrYXQIOv6+fujXF2diIiIS7j0TvvgwYNJSUlh5cqVtGvXjoSEBKKiojh+/Dj79u1jz549tiUriYmJLFmyhAkTJrBz505MJhNms5n8/HzCw8PtvuEL1l9czc3NZdy4ccTGxuLh4cHYsWMJCQkhJSWFtLQ0evTowahRoygpKWHjxo2Eh4fX+QagPhkZGWzfvp2XX36ZnTt30q9fP4KDgzl69Ci7du3CaDSyf//+a57j0Ucf5ezZszz44IO0adOGU6dO8be//Y3Dhw/Tu3dvJk2adON/WBF39sH86/dpHgCvTrI+RERExLWhHaxbQsbHx7Ns2TLWr1+PxWIhKCiImJgYZs2aZesXFxfHhg0bmDVrFqtWrcLDw4POnTvzzjvvMGHCBE6ePGl33uXLl5OUlER2djYVFRXU1NQwcOBAQkJCmDp1KkVFRaxbt46FCxfSsmVLnn32WTw8PJg5c2aDazcajeTn5zNv3jw2bdpk+0Eok8lEbGwsycnJ1z3HkCFDyM7OJicnh7Nnz9KsWTPatm3L7Nmz+c1vftPoy25ERERE5M7jtC0f5fbTlo9yWzVky0cRERFpFC5d0y4iIiIiIten0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuzuX7tIsT3BMKnt6urkKaupiWrq5ARETkrqHQ3hQt+yUEBrm6Crkb+BtdXYGIiMhdQaG9KYo0QZBCu4iIiEhToTXtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLi5Zq4uQJzgxBk4e9HVVdyZ/I0Q7O/qKkRERETsKLQ3Ramr4JtyV1dx54lpCa9NUmgXERERt6PQ3hR9VQyFp1xdhYiIiIg0Eq1pFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVul9IfIOUVCBsL/mNgwFz45LCrqxIREZE7gEK7yO1QXQ3DFsDrOyF1KCx6Ar4rg/5z4cvjrq5ORERE3JzTQntOTg4Gg6HeR25urrOmBmD69OlkZGQ4dY7GsHXrVv7jP/6De++9F39/f/z9/Wnfvj1z5szBYrG4ujxpqP5zYOwf6z+ekw/mL2B1Ksx7FCYNhQ/SwdMD5mXfvjpFRETkjuT0X0QdMGAACQkJDu1du3Z16rxZWVlEREQwY8YMp85zqxYsWMDHH3/MT37yEx577DEuXrzIO++8w4IFC8jNzeWjjz7Cw0MfiNzxcvIhPAQeib/SFhYMiX1g/Q6wVILRy2XliYiIiHtzemiPi4sjLS3N2dPcVhaLhcrKSgICAm75XFOmTOFnP/uZ3blefPFFBg4cyNatW1m9ejVPPfXULc8jLvbpEeh2L9R+A9bzPlj5LvzzOHRp65raRERExO25xS3cpUuX0qlTJ3x8fDAajXTo0IHly5fX2S8+Pp7Q0FC8vLwIDAykT58+7Nixw66fwWCguLiYgwcP2i3JOXjwoO34kCFDHM6fkZGBwWAgJyfH1paSkoLBYMBsNjN69GhMJhO+vr7k5eUBUFFRQWpqKtHR0Xh5eeHn50evXr3Ytm1bg6794YcfrjP8jxkzBoB//OMfDTqPuLkTJRDZ3LH9ctvxM7e3HhEREbmjOP1Oe0VFBUVFRXZtvr6+tGjRAoCnnnqKrKwsunfvzuTJk/H09GTLli2kpqZy4sQJFixYYBuXmZlJcHAwiYmJREZGUlhYyObNmxk0aBBms5lu3boBsHjxYtLT0wkMDGTKlCm28a1bt77p60hKSsLb25tx48ZhMBho27YtFouF+Ph4Dh06xKBBg0hOTqa0tJTs7GyGDh3K22+/zUMPPXRT8x09ehSAiIiIm65ZnKTyIpRVOLZZKqG43L7dFGC9u37uAhjr+H83H2/rv+cuOKdWERERaRKcfqc9MzOT6Ohou8fIkSMB65cws7KyePLJJ/n4449ZtGgRGRkZ7N+/n969e7NkyRJOnz5tO9euXbswm82sWLGCOXPmsGbNGt577z2qqqqYP3++rV9aWhpGoxGTyURaWprtERISctPXERAQwIEDB1i8eDGLFi2iR48ezJ49mwMHDpCVlcWWLVtIT09n6dKlfPbZZwQGBvLcc8/d1FwlJSX86U9/wtfXl7Fjx950zXLjLlZV2Z6Xl5fbPp25zGw2w67Prds2Xv0wfwEb/u7Q/uXWfEpKSsDXGywXKSoq4uuvv7adr+JMqfWJr7f9HLXnvMru3bupuqrOgoIC6xyX1J6j3uvQHJpDc2gOzaE5NIfL5rhRhpqamppbOkM9cnJyGDVqFMOHD7ct9bisTZs29O3blzFjxpCdnc2HH35IZGSkXZ81a9Ywe/Zs1q9fT1JSkt2x6upqzpw5w/nz5wHo27cvzZo14/DhK3teh4WFERERwYEDBxxqMxgMDB482LbE5bKMjAxmzpzJpk2bbG8sUlJSWLVqFZmZmaSkpNj1b9euHefPn+fDDz90mGP8+PHk5eVRWlpKYGDg9f5cNpWVlfz0pz8lPz+f3/3ud3afFFxPeXk5wcHBlLVPIajwVIPHySX3R8G2F6CV6dr9Ss7C3lr7q09dDRHNYdov7Nv/5UfWu+n3TYL7IiF3tv3x196Dp1fA/pe1pl1ERETq5fTlMe3bt3cI7ZcVFhZSU1NDz5496x1/7Ngx2/Nt27YxY8YM9u3b57AdYlhYWOMUXI8uXbo4tBUVFXHhwgWio6PrHXfs2DE6duzYoDmqqqr413/9V/Lz85k0adINBXa5jZoHwMAHHNsimzu2XxZ3D+w8ZN2v/eovo374JfgZoUMrp5UrIiIidz6nh/ZrqampwWAwsHbtWjw9PevscznQHzp0iISEBPz8/Bg/fjyxsbEEBARgMBh4/vnnOXfu3C3Xc/HixXqP1XW3vKamhjZt2vDSSy/VO66h6+gvB/b/9//+H7/85S9ZtmxZg8bJHWJkb+u2j2/uhpF9rG3F5bDJDMMf1HaPIiIick0uDe0xMTHs3buX9u3bEx8ff82+q1evxmKxsG7dOkaNGmV3bOLEiXh52Yceg8FQ77n8/f0pLS11aL96eU1DREZGUlZWRmJiYr1vOhricmDPy8vjqaeeYuXKlTd9LnFTI3tDfAdIXgYFRRAaCCvyoKoaXhjt6upERETEzbl0y8enn34agKlTp1JZWelw/MiRI7bnl0Nx7SX46enplJWVOYz18fGhvLzcoR0gKiqKgoICu+MnT57krbfeuqH6R4wYQVlZGdOmTavz+NX116e6upqHH36YvLw8xo4dy2uvvXZDNcgdwtPTup790b6wdAtMWwuhQdY19PdHubo6ERERcXMuvdM+ePBgUlJSWLlyJe3atSMhIYGoqCiOHz/Ovn372LNnj23JSmJiIkuWLGHChAns3LkTk8mE2WwmPz+f8PBwu2/4gvUXV3Nzcxk3bhyxsbF4eHgwduxYQkJCSElJIS0tjR49ejBq1ChKSkrYuHEj4eHhdb4BqE9GRgbbt2/n5ZdfZufOnfTr14/g4GCOHj3Krl27MBqN7N+//5rneOyxx8jNzeWee+4hNjaW//qv/7I7/qMf/Yhhw4Y1uCZxkQ/mX79P8wB4dZL1ISIiInIDXBrawbolZHx8PMuWLWP9+vVYLBaCgoKIiYlh1qxZtn5xcXFs2LCBWbNmsWrVKjw8POjcuTPvvPMOEyZM4OTJk3bnXb58OUlJSWRnZ1NRUUFNTQ0DBw4kJCSEqVOnUlRUxLp161i4cCEtW7bk2WefxcPDg5kzZza4dqPRSH5+PvPmzWPTpk22H4QymUzExsaSnJx83XNc3t3mq6++qvOO/eDBgxXaRURERO5yTtvyUW4/bfl4ixq65aOIiIjIbebSNe0iIiIiInJ9Cu0iIiIiIm5OoV1ERERExM0ptIuIiIiIuDmFdhERERERN6fQLiIiIiLi5ly+T7s4wT2h4Ont6iruPDEtXV2BiIiISJ0U2puiZb+EwCBXV3Fn8je6ugIRERERBwrtTVGkCYIU2kVERESaCq1pFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNNXN1AeIEJ87A2YuuruLG+Rsh2N/VVYiIiIi4HYX2pih1FXxT7uoqbkxMS3htkkK7iIiISB0U2puir4qh8JSrqxARERGRRqI17SIiIiIibk6hXURERETEzSm0i4iIiIi4OYV2ERERERE3p9AuIiIiIuLmFNpFRERERNycQrs0faU/QMorEDYW/MfAgLnwyWFXVyUiIiLSYArt0rRVV8OwBfD6TkgdCouegO/KoP9c+PK4q6sTERERaRCnhvacnBwMBkO9j9zcXGdOz/Tp08nIyHDqHI2loqKCp59+mpYtW+Ll5UV4eDi/+tWvsFgsri7NvfWfA2P/WP/xnHwwfwGrU2HeozBpKHyQDp4eMC/79tUpIiIicgtuyy+iDhgwgISEBIf2rl27OnXerKwsIiIimDFjhlPnaQwDBw4kPz+fhIQE4uPj2b17N6+88gr/93//R15enqvLu3Pl5EN4CDwSf6UtLBgS+8D6HWCpBKOXy8oTERERaYjbEtrj4uJIS0u7HVPdNhaLhcrKSgICAm75XKtXryY/P5/Ro0fzxhtv2NrHjBnDhg0b+N///V+GDx9+y/PclT49At3uBY9aHyr1vA9Wvgv/PA5d2rqmNhEREZEGcps17UuXLqVTp074+PhgNBrp0KEDy5cvr7NffHw8oaGheHl5ERgYSJ8+fdixY4ddP4PBQHFxMQcPHrRbknPw4EHb8SFDhjicPyMjA4PBQE5Ojq0tJSUFg8GA2Wxm9OjRmEwmfH19bXfAKyoqSE1NJTo6Gi8vL/z8/OjVqxfbtm1r0LWvX78egHnz5tm1X3795z//uUHnkTqcKIHI5o7tl9uOn7m99YiIiIjchNtyp72iooKioiK7Nl9fX1q0aAHAU089RVZWFt27d2fy5Ml4enqyZcsWUlNTOXHiBAsWLLCNy8zMJDg4mMTERCIjIyksLGTz5s0MGjQIs9lMt27dAFi8eDHp6ekEBgYyZcoU2/jWrVvf9HUkJSXh7e3NuHHjMBgMtG3bFovFQnx8PIcOHWLQoEEkJydTWlpKdnY2Q4cO5e233+ahhx665nkLCgpo3rw5HTt2tGvv2LEjzZs358CBAzddc5NSeRHKKhzbLJVQXG7fbgqw3l0/dwGMdfyfuY+39d9zF5xTq4iIiEgjui132jMzM4mOjrZ7jBw5EoCtW7eSlZXFk08+yccff8yiRYvIyMhg//799O7dmyVLlnD69GnbuXbt2oXZbGbFihXMmTOHNWvW8N5771FVVcX8+fNt/dLS0jAajZhMJtLS0myPkJCQm76OgIAADhw4wOLFi1m0aBE9evRg9uzZHDhwgKysLLZs2UJ6ejpLly7ls88+IzAwkOeee+665z1z5gyhoaF1HmvRooXd9TdlNTU1tucFBQWUlJTYXhcVFfHtm9ut2zZe/TB/ARv+7tj+dTFmsxl8vcFyEYDdu3dTVVVlPeF5a1j//uIFuzm+/vpr2+vy8nLbJzOXmc3ma762m6Oe69AcmkNzaA7NoTk0h+a4UYaaq5NSI8vJyWHUqFEMHz6cMWPG2B1r06YNffv2ZcyYMWRnZ/Phhx8SGRlp12fNmjXMnj2b9evXk5SUZHesurqaM2fOcP78eQD69u1Ls2bNOHz4yv7bYWFhRERE1Hmn2mAwMHjwYIcveWZkZDBz5kw2bdpke2ORkpLCqlWryMzMJCUlxa5/u3btOH/+PB9++KHDHOPHjycvL4/S0lICAwPr/Tt5eHjwox/9iM8++8zhWGxsLEeOHKGioqKOkfbKy8sJDg6mrH0KQYWnrtvfrdwfBdtegFam+vuUnIW9tfZXn7oaIprDtF/Yt//Lj6x30++bBPdFQu5s++OvvQdPr4D9L2tNu4iIiLi927I8pn379g6h/bLCwkJqamro2bNnveOPHTtme75t2zZmzJjBvn37HLZDDAsLa5yC69GlSxeHtqKiIi5cuEB0dHS9444dO+aw9OVq3t7eVFZW1nnswoULGI3GGy+2KWoeAAMfcGyLbO7YflncPbDzkHW/9qu/jPrhl+BnhA6tnFauiIiISGO5LaH9WmpqajAYDKxduxZPT886+1wO9IcOHSIhIQE/Pz/Gjx9PbGwsAQEBGAwGnn/+ec6dO3fL9Vy8eLHeY3XdLa+pqaFNmza89NJL9Y673jp6k8lEcXFxncdOnz5tW/svN2Fkb+u2j2/uhpF9rG3F5bDJDMMf1HaPIiIickdweWiPiYlh7969tG/fnvj4+Gv2Xb16NRaLhXXr1jFq1Ci7YxMnTsTLyz6AGQyGes/l7+9PaWmpQ/vVy2saIjIykrKyMhITE+t903E9nTp1YuvWrXz++ed2d+Q///xzSkpK+MlPfnJT5xWsoT2+AyQvg4IiCA2EFXlQVQ0vjHZ1dSIiIiIN4vItH59++mkApk6dWucSkSNHjtieXw7FtZfhp6enU1ZW5jDWx8eH8vJyh3aAqKgoCgoK7I6fPHmSt95664bqHzFiBGVlZUybNq3O41fXX5/L6/VfeOEFu/bLr5OTk2+oJrmKp6d1PfujfWHpFpi2FkKDrOvn749ydXUiIiIiDeLyO+2DBw8mJSWFlStX0q5dOxISEoiKiuL48ePs27ePPXv22JasJCYmsmTJEiZMmMDOnTsxmUyYzWby8/MJDw+3+5YvWH9xNTc3l3HjxhEbG4uHhwdjx44lJCSElJQU0tLS6NGjB6NGjaKkpISNGzcSHh5e5xuA+mRkZLB9+3Zefvlldu7cSb9+/QgODubo0aPs2rULo9HI/v37r3mO5ORk/vSnP7FhwwbKy8vp3bs3+fn55ObmMnDgQH7xi19cc/xd7YP51+/TPABenWR9iIiIiNyBXB7awbolZHx8PMuWLWP9+vVYLBaCgoKIiYlh1qxZtn5xcXFs2LCBWbNmsWrVKjw8POjcuTPvvPMOEyZM4OTJk3bnXb58OUlJSWRnZ1NRUUFNTQ0DBw4kJCSEqVOnUlRUxLp161i4cCEtW7bk2WefxcPDg5kzZza4dqPRSH5+PvPmzWPTpk22H4QymUzExsY2+C751q1bmTx5Mv/7v//L//t//4/mzZszYcIEfv/73ze4FhERERFpmpy65aPcXk1+y0cRERGRu5TL17SLiIiIiMi1KbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm3OLfdqlkd0TCp7erq7ixsS0dHUFIiIiIm5Lob0pWvZLCAxydRU3zt/o6gpERERE3JJCe1MUaYKgOzC0i4iIiEidtKZdRERERMTNKbSLiIiIiLg5hXYRERERETen0C4iIiIi4uYU2kVERERE3JxCu4iIiIiIm1NoFxERERFxcwrtIiIiIiJuTqFdRERERMTNKbSLiIiIiLg5hXYRERERETfXzNUFiBOcOANnL7q6Cnv+Rgj2d3UVIiIiInckhfamKHUVfFPu6iquiGkJr01SaBcRERG5SQrtTdFXxVB4ytVViIiIiEgj0Zp2ERERERE3p9AuIiIiIuLmFNpFRERERNycQruIiIiIiJtTaBcRERERcXMK7SIiIiIibk6hXe58pT9AyisQNhb8x8CAufDJYVdXJSIiItJoFNrlzlZdDcMWwOs7IXUoLHoCviuD/nPhy+Ourk5ERESkUTgttOfk5GAwGOp95ObmOmtqAKZPn05GRoZT52gMQ4YMuebfKTIy0tUlulb/OTD2j/Ufz8kH8xewOhXmPQqThsIH6eDpAfOyb1+dIiIiIk7k9F9EHTBgAAkJCQ7tXbt2deq8WVlZREREMGPGDKfOc6ueeeYZBg4c6NC+detW8vLy+OlPf+qCqu4gOfkQHgKPxF9pCwuGxD6wfgdYKsHo5bLyRERERBqD00N7XFwcaWlpzp7mtrJYLFRWVhIQEHDL5xo2bBjDhg1zaH/jjTcAmDx58i3P0aR9egS63QsetT406nkfrHwX/nkcurR1TW0iIiIijcQt1rQvXbqUTp064ePjg9FopEOHDixfvrzOfvHx8YSGhuLl5UVgYCB9+vRhx44ddv0MBgPFxcUcPHjQbqnJwYMHbceHDBnicP6MjAwMBgM5OTm2tpSUFAwGA2azmdGjR2MymfD19SUvLw+AiooKUlNTiY6OxsvLCz8/P3r16sW2bdtu+u/x2Wef8emnn9KhQwf69Olz0+e5K5wogcjmju2X246fub31iIiIiDiB0++0V1RUUFRUZNfm6+tLixYtAHjqqafIysqie/fuTJ48GU9PT7Zs2UJqaionTpxgwYIFtnGZmZkEBweTmJhIZGQkhYWFbN68mUGDBmE2m+nWrRsAixcvJj09ncDAQKZMmWIb37p165u+jqSkJLy9vRk3bhwGg4G2bdtisViIj4/n0KFDDBo0iOTkZEpLS8nOzmbo0KH/v717j4qy2v8H/h4GGRCGgQlQvIGCCke8VBbebyksjY6K4VftgpqZHH8dLaGTxgHTjpJZXtLW8SCigqwID2omXlKwzFuJZWZgXssLJnJNwRFk//7gzMQ4M/oAg/Oo79das4T97GdfPjNsPzzseQZffPEFhg0bVu++li1bBiEEXnrppQaP94FUVQ2UVZiW6aqAa+XG5VqX2qvrlbcAlZmXsaND7b+Vt5pmrERERET3k2giGRkZAoDZx6BBg4QQQuzevVsAEJGRkSbn9+7dWzg6Oopr164ZykpKSkzqHTx4UNjb24tRo0YZlXt4eIigoCCzYwMgQkNDTcoXLFggAIiMjAxD2auvvioAiKCgIKHT6YzqR0dHCwAiJSXFqLywsFA89thjFvu/m+rqavHYY48JlUoliouL63VuWVmZACDK/KcKgdHyeXT+f0J3rsBorPv37zf6/uDBg6J69zHJbZb/eFocP35cCOfxQkxeYdrmtiO1dXccNe6jutrw/YkTJ4xifOHCBfHrr78axfP48eN3HbfZebAP9sE+2Af7YB/sg33co4/6UgghRFP8MrBx40ZERETgueeew/jx442OtWvXDn379sX48eORnp6Ow4cPm9wlZd26dYiNjUVqaipeeOEFo2M1NTUoLi7GzZs3AQB9+/aFvb09zpz5897cnp6eaNmyJY4fP24yNoVCgdDQUMMWF72FCxdizpw5yMjIwPPPPw+gdntMYmIiVq1ahalTpxrV9/Pzw82bN3H48GGTPl577TXs2LEDpaWlUKvV9wqXQWpqKl566SWMGDEC27Ztk3weAJSXl0Oj0aDMfypcTxfW69wm1bk1kP0u0Ep793ol14HcO+6vPmst0NIdiBlpXN4vsPZqesfpQEdvICvW+HjSbmDKJ8CPS7innYiIiB54Tb49xt/f3yRp1zt9+jSEEHj66actnn/p0iXD19nZ2Zg9ezaOHTsGnU5nVM/T09M6A7aga9euJmUXL17ErVu30LZtW4vnXbp0CQEBAZL7SUxMBABMnz69/oN80Lm7AEO7m5Z5u5uW6/XwBfbl1d6vve6bUQ+fApqrgE6tmmy4RERERPdLkyftdyOEgEKhwPr166FUKs3W0Sf0eXl5GDFiBJo3b47XXnsNXbp0gYuLCxQKBf7xj3+gsrKy0eOprq62eMzc1XIhBNq1a4eEhASL59VnH/2lS5dw4MABtG3b1uxtMsmM53vX3vYx8xDw/P/etHutHMg4ADzXk7d7JCIiooeCTZP29u3bIzc3F/7+/ujVq9dd665duxY6nQ4pKSmIiIgwOhYVFYVmzYyTM4VCYbEtZ2dnlJaWmpTX3V4jhbe3N8rKyjB27FiLv3TUx9KlS1FdXY1x48Y1uq1HxvO9gV6dgEkrgJ8vAh5q4JMdwO0a4F3GkYiIiB4ONr3l45QpUwAAs2bNQlVVlcnxc+fOGb7WJ8V3bsGfN28eysrKTM51dHREeXm5STkAtG7dGj///LPR8StXrmDz5s31Gv+YMWNQVlaGmJgYs8frjl+K9PR02NvbY8aMGfU675GmVNbuZ/+/vsDybUDMesDDtXYPfefWth4dERERkVXY9Ep7aGgopk6div/85z/w8/PDiBEj0Lp1a1y+fBnHjh3Dt99+a9iyMnbsWHz44YeYNm0a9u3bB61WiwMHDuDgwYNo0aIFbt++bdR2t27dkJWVhVdeeQVdunSBnZ0dJk6cCDc3N0ydOhXR0dF46qmnEBERgZKSEnz22Wdo0aKF2V8ALFm4cCG++uorLFmyBPv27UP//v2h0Wjw66+/Yv/+/VCpVPjxxx8ltbV9+3ZcuHABAwcOROvWTDYN9s6/dx13F2D19NoHERER0UPIpkk7UHvv9V69emHFihVITU2FTqeDq6sr2rdvj3feecdQr0ePHvj000/xzjvvIDExEXZ2dggKCsLOnTsxbdo0XLlyxajdlStX4oUXXkB6ejoqKioghMDQoUPh5uaGWbNm4eLFi0hJScH7778PLy8vzJw5E3Z2dpgzZ47ksatUKhw8eBDx8fHIyMgwfCCUVqtFly5dMGnSJMltffLJJwBgcocaIiIiIqImu+Uj3X8P/C0fiYiIiMgsm+5pJyIiIiKie2PSTkREREQkc0zaiYiIiIhkjkk7EREREZHMMWknIiIiIpI5m9/ykZqArwegdLD1KP7U3svWIyAiIiJ6oDFpfxiteBVQu9p6FMacVbYeAREREdEDi0n7w8hbC7jKLGknIiIiogbjnnYiIiIiIplj0k5EREREJHNM2omIiIiIZI5JOxERERGRzDFpJyIiIiKSOSbtREREREQyx6SdiIiIiEjmmLQTEREREckck3YiIiIiIplj0k5EREREJHNM2omIiIiIZI5JOxERERGRzDFpJyIiIiKSOSbtREREREQyx6SdiIiIiEjmmLQTEREREckck3YiIiIiIplj0k5EREREJHNM2omIiIiIZI5JOxERERGRzDFpJyIiIiKSOSbtREREREQyx6SdiIiIiEjmmLQTEREREcmcva0HQNYjhAAAlJeX23gkRERERHQ3arUaCoVCcn0m7Q+RoqIiAEDbtm1tPBIiIiIiupuysjK4urpKrs+k/SGi1WoBAL/99hs0Go2NRyN/5eXlaNu2LS5cuFCvH5pHEWMlHWMlHWMlHWMlHWNVP4yXdNaOlVqtrld9Ju0PETu72rcoaDQa/uDVg6urK+MlEWMlHWMlHWMlHWMlHWNVP4yXdLaKFd+ISkREREQkc0zaiYiIiIhkjkn7Q0SlUiE+Ph4qlcrWQ3kgMF7SMVbSMVbSMVbSMVbSMVb1w3hJZ+tYKYT+PoFERERERCRLvNJORERERCRzTNqJiIiIiGSOSTsRERERkcwxaZeB/Px8DBs2DM7OzmjZsiXeeust3Lp1657nCSGQkJCAdu3awcnJCb1798ahQ4dM6l2+fBljxoyBWq2GVqvFlClTUF5eblJv69at6N69OxwdHdGpUyckJydbZX7WZOtY3b59G4sWLcKAAQPg4eEBrVaLwYMHY9++fVadpzXYOlZ3ys3NhVKphIuLS6Pm1RTkEqubN28iLi4O7du3h0qlQrt27RATE2OVOVqLHGKl/zkMCAhA8+bN0aFDB8TExOD69etWm6e1NGW8CgsLMWPGDAQHB0OlUt31Z+tRX9+lxIrre636vK70HtX1vT6xssr6LsimiouLhbe3txgwYIDYsWOHSEpKEhqNRkyfPv2e5y5cuFA4ODiIjz76SOzevVuMHj1aqNVqcebMGUOdW7duiaCgIBEUFCQ+//xz8emnn4o2bdqIZ5991qitffv2CaVSKV577TWRnZ0tYmNjhUKhEBkZGVafc0PJIVZ//PGHcHNzEzNnzhRffPGF2L59uxg9erRQKpViz549TTLvhpBDrOqqqakRvXr1Ei1atBDOzs5Wm6c1yCVWt2/fFiEhIcLf318kJyeLvXv3inXr1ok5c+ZYfc4NJZdYvfvuu8Le3l4sXLhQZGdni+XLlwsXFxcxYcIEq8+5MZo6Xt9//73w8vISYWFhok+fPhZ/tri+S4sV1/daUl9Xeo/y+i41VtZa35m029iCBQuEs7OzKCoqMpStWrVKKJVKcenSJYvnVVZWCldXVzF79mxDmU6nEz4+PiIqKspQlpaWJhQKhcjPzzeU7dy5UwAQhw8fNpSFhISIPn36GPUxfvx4ERgY2Kj5WZMcYlVdXS2Ki4uN2q+urhYBAQEiLCys0XO0FjnEqq6kpCTh7+8vZs+eLbtFXS6xWr16tdBoNOLy5cvWmprVySVWnTt3FpGRkUZ9xMXFCZVKJaqqqhozRatq6njdvn3b8HV8fLzFny2u79JixfW9ltTXld6jvL5LjZW11nduj7Gx7du3Y+jQodBqtYaysWPHoqamBrt27bJ43oEDB1BeXo6xY8cayhwcHBAeHo6srCyj9rt164bOnTsbyoYNGwatVmuop9PpkJOTg4iICKM+xo0bh7y8PJw/f76x07QKOcRKqVTC3d3dqH2lUolu3brh8uXLjZ6jtcghVnqlpaV4++23sWTJEjg4OFhjelYll1glJiYiIiIC3t7e1pqa1cklVlVVVdBoNEZ9aDQa1NTUNGp+1tbU8bKzu/d/4Vzfa0mJFdf3WlJipfeor+9SY2Wt9Z1Ju43l5+cjICDAqMzNzQ3e3t7Iz8+/63kATM4NDAzEb7/9hsrKSovtKxQKBAQEGNo4c+YMqqqqzLZVty9bk0OszKmursahQ4cM8ZIDOcUqNjYWTz75JMLCwho8n6Ykh1hVVVXh6NGj8PHxwcsvvwxnZ2eo1WqMHTsWV65cafQcrUUOsQKAKVOmICUlBdnZ2bh+/Tq+/fZbfPzxx5g2bRrs7e0bNUdraup4ScH1XXqszHkU1/f6eNTXdymsub7LZ3V7RJWUlMDNzc2k3N3dHcXFxXc9T6VSwdHR0eQ8IQRKSkrg5OQkqf2SkhIAMKmnv+Jwt3HcT3KIlTmLFi3CpUuX8MYbb0ieS1OTS6x++OEHJCUl4fvvv2/wXJqaHGJVVFSEqqoqvP/++xgwYAA2bdqEwsJCvPXWWwgPD8eBAwcaNUdrkUOsAGD27NnQ6XQYOnQoxP8+H/DFF1/E0qVLGzSvptLU8ZI6BoDre0M9iuu7VFzfpcXKmus7k3aiRvjyyy8RHx+PuLg4PPnkk7YejqwIITB9+nT87W9/M7laQcb02zrUajUyMzMNH5HdokULDBs2DNnZ2RgyZIgthygrK1aswLJly7BkyRI8/vjjOHHiBP75z3/i9ddfx8qVK209PHpIcH23jOu7dNZc37k9xsbc3d1RVlZmUl5SUmK0B8vceTqdDjdv3jQ5T6FQGK6iSGlfX/fOevorNHcbx/0kh1jVdfToUYwZMwYTJkxAXFxcfafTpOQQq/T0dOTl5eHvf/87SktLUVpaami37te2JodYubm5QaFQoE+fPoYFHQAGDRoEpVKJEydONGhu1iaHWBUVFSE6Ohrz5s3DjBkzMGDAAERFRWHZsmX45JNP8MsvvzRmilbV1PGSOgaA63t9PcrruxRc36XHyprrO5N2GzO3B7isrAwFBQV3/e1Vf+zkyZNG5fn5+YZ7ilpqXwiBkydPGtrw8/NDs2bNTOpZ2tNlK3KIld7p06cxfPhw9OnTB6tXr27wnJqKHGKVn5+PkpIS+Pr6wt3dHe7u7nj//fdx48YNuLu7Y+7cuY2dplXIIVbNmzeHr6+vxb7k8h+gHGJ15swZ6HQ69OjRw6je448/bjguF00dLym4vtd/a8yjvr5LwfVdeqysub4zabex4cOHY/fu3SgtLTWUZWRkwM7ODiEhIRbP69OnD1xdXZGRkWEoq6qqQmZmJkaMGGHU/rFjx3Dq1ClD2Z49e1BUVGSop1KpMHjwYGzcuNGoj/T0dAQGBt71xXY/ySFWAFBQUICQkBC0a9cOGzduRLNmzaw0Q+uRQ6wmTpyInJwco0dkZCQcHR2Rk5ODqVOnWnHGDSeHWAFAWFgY9u/fb7SAZ2dn4/bt27L507wcYuXj4wOg9kpoXbm5uQAgm/UKaPp4ScH1vX64vkvD9b1+rLa+N+qGkdRo+hv/Dxw4UOzcuVOsWbNGuLm5mdz4f8iQIcLPz8+obOHChUKlUomlS5eKPXv2iDFjxlj8sJKuXbuKrVu3ivT0dNG2bVuLH64UFRUlcnJyRFxcnFAoFOKzzz5rusnXkxxiVVFRIbp37y7UarX4/PPPxcGDBw2Po0ePNm0A6kEOsTJHyj1/7ze5xOq3334Tbm5uIiQkRGzbtk2sXbtWtGzZUvTr10/U1NQ0XQDqQS6xGjVqlFCr1WLx4sUiOztbfPzxx0Kr1YqhQ4c23eQboKnjJYQQGRkZIiMjQ0RERAhHR0fD9+fPnzfU4fpe616x4vr+Jymvqzs9iuu7ENJiZa31nUm7DPz888/imWeeEU5OTsLLy0tER0cLnU5nVGfgwIHCx8fHqKympkYsWLBAtGnTRqhUKhEcHCwOHDhg0v7FixdFeHi4cHFxEW5ubmLy5MmirKzMpN6WLVtE165dhYODg/D39xdJSUlWnac12DpW586dEwDMPu7s09ZsHStz5LioCyGfWH3//fdi4MCBwtHRUWi1WjF58mRRUlJizak2mhxiVVZWJqKjo4Wfn59wdHQU7du3F6+//rrJB+PIQVPHy9J6lJycbFSP6/u9Y8X1/U9SX1d1Parru9RYWWN9V/yvQyIiIiIikinuaSciIiIikjkm7UREREREMseknYiIiIhI5pi0ExERERHJHJN2IiIiIiKZY9JORERERCRzTNqJiIiIiGSOSTsRERERkcwxaSciIiNXr16FRqNBYmKiUfnEiRPh6+trm0E9JObOnQuFQoHz58/fl/7Wrl1r0l9lZSVatWqFd999976MgYisg0k7EREZiY2NhaenJyZNmiSp/pUrVxAdHY2goCCo1Wq4urqiY8eOGDduHDIzM43qDho0CC4uLhbb0ie1R44cMXu8pKQETk5OUCgUSElJsdiOr68vFAqF4eHg4ABfX19MmTIFFy5ckDSvh5WTkxPefvttfPDBBygoKLD1cIhIIibtRERkcPHiRaxZswavv/467O3t71n/119/Rffu3bFy5Ur06tULCQkJWLhwIcLCwpCfn4/k5GSrjm/Dhg3Q6XRo37491qxZc9e6bdq0QUpKClJSUrBs2TIEBwdjzZo1CA4OxrVr16w6rgfNK6+8AoVCgY8++sjWQyEiie69IhMR0SNj1apVUCgUGD9+vKT6ixcvxtWrV7F582aMHDnS5PiVK1esOr6kpCQMHjwYI0eOxMyZM3H27Fl06NDBbF2NRoMXX3zR8H1UVBS8vLywYsUKJCcnIyYmxqpje5A4OzsjPDwca9euxXvvvQeVSmXrIRHRPfBKOxFRI+j3DO/Zswfz5s2Dj48PnJycEBwcjEOHDgEAvvrqK/Tr1w/Ozs7w9vbG/PnzzbZ15MgRjB49Gh4eHlCpVOjcuTP+9a9/obq62qjet99+i4kTJ6JTp05o3rw51Go1+vbti02bNpm0OXHiRCgUCpSVlRmSVkdHR/Tt2xeHDx82qZ+RkYGePXvCy8tL0vxPnToFAHjmmWfMHm/ZsqWkdqQ4evQofvjhB0RGRmLChAmwt7e/59X2O4WGhgIATp8+bbHO9u3boVAosHz5crPHe/fuDU9PT1RVVQGo3/Nhjv45MkehUGDixIkm5enp6ejXrx/UajWaN2+O4OBgbNy4UVJ/esOHD8e1a9eQk5NTr/OIyDaYtBMRWcHbb7+NzZs3Y8aMGYiPj8fZs2cREhKCzZs3Izw8HP3798fixYsREBCAuLg4pKamGp2/bds29O3bF7/88gtmzZqF5cuXo3fv3oiLizO56r1p0ybk5+dj7NixWLZsGd555x0UFxcjPDwcaWlpZscXGhqKixcvIi4uDrNnz8ZPP/2EZ599Fn/88Yehzu+//46TJ0/i6aefljxvPz8/AEBiYiKEEJLPu3btmtlHRUWFxXOSkpLg4uKCMWPGwMPDA2FhYVi3bh1qamok96v/JcPDw8NinZCQELRs2RLr1683e/6hQ4cwYcIENGvWDEDDno/GiI2Nxbhx46BWqzF//nwkJCSgefPmiIiIwMqVKyW307t3bwDA3r17rT5GImoCgoiIGiw5OVkAEI8//rjQ6XSG8i1btggAwt7eXnz33XeGcp1OJ1q2bCl69eplKKusrBQtWrQQ/fv3F1VVVUbtf/TRRwKAyMnJMZRdv37dZBw3btwQnTp1EoGBgUblkZGRAoCIiooyKv/ss88EAPHvf//bUJadnS0AiGXLlpmda2RkpPDx8TEqO3PmjHB1dRUARNu2bcWECRPEkiVLxJEjR8y2MXDgQAHgno+6MdPHyM3NTURGRhrKNm/eLACIrKwsk358fHxEQECAKCwsFIWFheLs2bNizZo1QqPRCHt7e3H8+HGz49OLjo4WAMSJEyeMymNjYwUAkZubayirz/MRHx8vAIhz584ZyvTPkTkAjOacm5srAIjZs2eb1B05cqRQq9WivLzcUKZ/fdbtry57e3sRFhZm9hgRyQuvtBMRWUFUVBQcHBwM3/fv3x8AEBwcjJ49exrKHRwc8PTTTxuu+ALAl19+id9//x2TJk1CaWmp0ZXnESNGAAB27dplqO/s7Gz4uqKiAkVFRaioqMCQIUOQl5eH8vJyk/G98cYbRt8PGTIEAIzGUVhYCADQarWS592hQwccO3YM06dPBwCkpaXhjTfeQM+ePdGtWzfk5uaanOPo6Igvv/zS7OOll14y209mZiZKS0sRGRlpKBsxYgQ8PT0tbpHJz8+Hp6cnPD090aFDB0yePBkeHh7YsmULgoKC7jovfT91r7YLIZCamoqgoCA88cQThvKGPB8NtWHDBigUCkRGRpr8leKvf/0r/vjjDxw8eFBye1qtFlevXrXa+Iio6fCNqEREVnDnmyHd3d0BAO3btzep6+7ujqKiIsP3eXl5AIDJkydbbP/33383fH316lXExsZiy5YtZhOu0tJSuLq63nV8jz32GAAYjUO/r1rUY5sLUHt7xRUrVmDFihUoKCjAN998g5SUFGzduhVhYWE4ceKE0S8CSqUSQ4cONdvWN998Y7Y8KSkJnp6eaNOmjdF+9JCQEGRkZODatWsmW158fX0N95p3cHBAq1at4O/vL2lO+sR8w4YNWLBgAezs7PD111/j/PnzWLRokVHdhjwfDZWXlwchBAICAizWqftauRchhMX99EQkL0zaiYisQKlU1qu8Ln2S/MEHH6BHjx5m67Rq1cpQNyQkBHl5eZgxYwZ69uwJjUYDpVKJ5ORkpKWlmd3jbWkcdRN0T09PAEBxcfE9x2yJt7c3IiIiEBERgRdeeAFpaWnIysoyuotLfZ07dw45OTkQQqBTp05m66SmpmLmzJlGZc7OzhZ/OZDi5ZdfxsyZM5GdnY2hQ4di/fr1UCqVRnNp6PNRl6Wk+c43IOv7UygU2L59u8XntEuXLpLnWFJSYnjeiUjemLQTEdlYx44dAUhLMn/88UccO3YMcXFxJp9ouXr16kaNQ5/s1d0y0xi9evVCWloaLl261Kh2kpOTIYRAYmIi3NzcTI7HxsZizZo1Jkl7Y02YMAExMTFYv349+vbti40bN2LYsGHw9vY21LHG86H/K0RxcbHRXyTOnj1rUrdjx47YsWMH2rVrh8DAwIZMy+D8+fOorq6+51YhIpIH7mknIrKx0NBQeHl5ISEhwexV7srKSsNdXvRXV+/cwvLTTz9JvsWgJZ6enujSpYvhVpVS7N27F5WVlSblNTU12Lp1KwDgL3/5S4PHVFNTg7Vr16Jr166YMmUKnn/+eZPH+PHjcfz4cXz33XcN7sccT09PDB8+HJmZmdiwYQPKy8uN9tQD1nk+9H892L17t1H5hx9+aFJXv+d/zpw5uH37tsnx+myN0T/PAwcOlHwOEdkOr7QTEdmYs7Mz1q9fj1GjRqFz586YPHky/P39UVpaivz8fGRmZmLTpk0YNGgQAgMD0aVLFyxatAgVFRXo3LkzfvnlF6xatQpdu3Y1+8bP+oiIiMD8+fNRUFBgdEXZksWLF2P//v147rnn8MQTT0Cj0eDKlSv473//i9zcXAwePBjPPvtsg8eza9cuXLhwAa+88orFOmPGjMHcuXORlJSEp556qsF9mRMZGYnPP/8cs2bNgkajwahRo4yOW+P5GD9+PObMmYOpU6ciPz8fWq0WO3bsMPuprU899RTmzp2LuXPnokePHoiIiECrVq1QUFCA3NxcZGVl4datW5LmlpWVBQ8PDwwePFhSfSKyLSbtREQyEBoaiu+++w4JCQlITU1FYWEh3N3d4efnhzfffBPdunUDUHtld9u2bYiOjsa6detw48YNBAUFYd26dTh27Fijk/ZXX30V7733HtLS0jBr1qx71o+NjUVGRga+/vpr7Ny5E8XFxXB2dkZgYCA+/PBDTJ8+HXZ2Df+jblJSEgAgPDzcYp2goCB06tQJn376KZYsWQInJ6cG93ensLAwaLVaFBcXY8qUKXB0dDQ6bo3nw9XVFVlZWXjzzTexYMECuLi4IDw8HKmpqYY3NNcVHx+Pnj17Yvny5Vi6dClu3LgBLy8vBAUFWfxAqDvduHEDmZmZiIqK4qehEj0gFKK+twkgIqKH2rRp07Br1y6cPHnS8AFCQO0nd+7duxfnz5+33eCoXtauXYtJkybh3Llz8PX1NZTrPwTq1KlTkv6iQkS2xz3tRERkZN68eSgqKkJycrKth0JNoLKyEgkJCYiJiWHCTvQA4fYYIiIy4uXlhbKyMlsPg5qIk5MTCgoKbD0MIqonXmknIiIiIpI57mknIiIiIpI5XmknIiIiIpI5Ju1ERERERDLHpJ2IiIiISOaYtBMRERERyRyTdiIiIiIimWPSTkREREQkc0zaiYiIiIhkjkk7EREREZHM/X/kPkeWlQT/HQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 800x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the SHAP values\n",
    "shap.plots.bar(explanation, max_display=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x650 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the SHAP values\n",
    "shap.plots.bar(explanation[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: Shapley value analysis to explain importance of particular atom/node and bond/edge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f3993f6dd20>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mol = Chem.MolFromSmiles(test_mol)\n",
    "mol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of atoms: 24, Number of bonds: 27\n"
     ]
    }
   ],
   "source": [
    "n_atoms = mol.GetNumAtoms()\n",
    "n_bonds = mol.GetNumBonds()\n",
    "print(f\"Number of atoms: {n_atoms}, Number of bonds: {n_bonds}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the featurizer\n",
    "atom_featurizer = CustomMultiHotAtomFeaturizer.v2() # chemprop v2 default atom featurizer settings\n",
    "bond_featurizer = CustomMultiHotBondFeaturizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A helper function to get predictions from a molecule with ability to keep or remove specific atom/node or bond/edge\n",
    "def get_predictions(keep_atoms: Optional[List[bool]], keep_bonds: Optional[List[bool]], mol: str) -> float:\n",
    "    featurizer = CustomSimpleMoleculeMolGraphFeaturizer(\n",
    "        atom_featurizer=atom_featurizer,\n",
    "        bond_featurizer=bond_featurizer,\n",
    "        keep_atoms=keep_atoms,\n",
    "        keep_bonds=keep_bonds\n",
    "    )\n",
    "    test_data = [data.MoleculeDatapoint.from_smi(mol)]\n",
    "    test_dset = data.MoleculeDataset(test_data, featurizer=featurizer)\n",
    "    test_loader = data.build_dataloader(test_dset, shuffle=False, batch_size=1)\n",
    "\n",
    "    with torch.inference_mode():\n",
    "        trainer = pl.Trainer(\n",
    "            logger=False,\n",
    "            enable_progress_bar=False,\n",
    "            accelerator=\"cpu\",\n",
    "            devices=1\n",
    "        )\n",
    "        test_preds = trainer.predict(mpnn, test_loader)\n",
    "    return test_preds[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/knathan/anaconda3/envs/chemprop_delete/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:425: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=11` in the `DataLoader` to improve performance.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction with all atoms and bonds kept: tensor([2.2535])\n",
      "Prediction with all atoms and bonds removed: tensor([2.1880])\n"
     ]
    }
   ],
   "source": [
    "# example prediction with different keep_atoms and keep_bonds\n",
    "\n",
    "# keep all atoms and bonds\n",
    "keep_atoms_0 = [True] * n_atoms\n",
    "keep_bonds_0 = [True] * n_bonds\n",
    "\n",
    "# remove all atoms and bonds\n",
    "keep_atoms_1 = [False] * n_atoms\n",
    "keep_bonds_1 = [False] * n_bonds\n",
    "\n",
    "pred_0 = get_predictions(keep_atoms_0, keep_bonds_0, test_mol)\n",
    "pred_1 = get_predictions(keep_atoms_1, keep_bonds_1, test_mol)\n",
    "\n",
    "print(f\"Prediction with all atoms and bonds kept: {pred_0}\") # expected 2.2535\n",
    "print(f\"Prediction with all atoms and bonds removed: {pred_1}\") # expected 2.1880"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example wrapper class for use as the model input in SHAP explainer\n",
    "class MoleculeModelWrapper:\n",
    "    def __init__(self, mol: str, n_atoms: int, n_bonds: int):\n",
    "        self.mol = mol\n",
    "        self.n_atoms = n_atoms\n",
    "        self.n_bonds = n_bonds\n",
    "    def __call__(self, X):\n",
    "        preds = []\n",
    "        for keep_features in X:\n",
    "            try:\n",
    "                # unpacking X, indices corresponds to atom.GetIdx() and bond.GetIdx() from rdkit mol, adapt as needed\n",
    "                keep_atoms = keep_features[:self.n_atoms]\n",
    "                keep_bonds = keep_features[self.n_atoms:self.n_atoms + self.n_bonds]\n",
    "            except Exception as e:\n",
    "                print(f\"Invalid input: {keep_features}\")\n",
    "                raise e\n",
    "            pred = get_predictions(keep_atoms, keep_bonds, self.mol)\n",
    "            preds.append([pred.item()])\n",
    "        return np.array(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example masker function for use with SHAP explainer\n",
    "# The masker function takes in a binary mask and the input data X, and returns the masked input data. This simulates the effect of masking out certain features.\n",
    "def binary_masker(binary_mask, x):\n",
    "    masked_x = deepcopy(x)\n",
    "    masked_x[binary_mask == 0] = 0\n",
    "    return np.array([masked_x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the model wrapper with the test molecule, number of atoms and bonds\n",
    "model_wrapper = MoleculeModelWrapper(test_mol, n_atoms, n_bonds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.25354147]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test the model wrapper with a random node/edge choice\n",
    "keep_features = [1] * (n_atoms + n_bonds)\n",
    "feature_choice = np.array([keep_features])\n",
    "model_wrapper(feature_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the SHAP explainer with the model wrapper and masker\n",
    "explainer = shap.PermutationExplainer(model_wrapper, masker=binary_masker)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "PermutationExplainer explainer: 2it [00:25, 25.79s/it]               \n"
     ]
    }
   ],
   "source": [
    "# Compute SHAP values, using 200 evaluations of different node/edge choices (notice that nodes and edges are masked out randomly by the binary masker, so the results may vary between runs)\n",
    "explanation = explainer(feature_choice, max_evals=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ".values =\n",
       "array([[-6.33835793e-04,  2.00152397e-04,  8.77737999e-04,\n",
       "        -1.20162964e-04, -1.70385838e-03,  1.32679939e-04,\n",
       "         5.65052032e-04, -1.49548054e-03,  1.45280361e-03,\n",
       "         7.84397125e-05,  7.94768333e-04,  1.32918358e-03,\n",
       "         1.59931183e-03,  7.92026520e-04, -1.05524063e-03,\n",
       "         1.27375126e-03,  1.26934052e-03, -5.46216965e-04,\n",
       "         2.07734108e-03,  9.27805901e-04,  1.94215775e-03,\n",
       "         1.70767307e-03,  9.18865204e-04,  2.30920315e-03,\n",
       "         1.02865696e-03,  2.66933441e-03,  3.65734100e-04,\n",
       "         1.01172924e-03,  1.39999390e-03,  1.10065937e-03,\n",
       "         1.54471397e-03,  1.68943405e-03,  1.58667564e-03,\n",
       "         8.28027725e-04,  2.80642509e-03,  2.18117237e-03,\n",
       "         2.17568874e-03,  9.46164131e-04,  1.96087360e-03,\n",
       "         2.82001495e-03,  2.58827209e-03,  2.84719467e-03,\n",
       "         2.18105316e-03,  2.61569023e-03,  1.97517872e-03,\n",
       "         2.07221508e-03,  2.10452080e-03,  1.83522701e-03,\n",
       "         1.78325176e-03,  2.54166126e-03,  2.21943855e-03]])\n",
       "\n",
       ".base_values =\n",
       "array([[2.18796897]])\n",
       "\n",
       ".data =\n",
       "array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the SHAP values\n",
    "explanation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the SHAP values, notice that \"feature 0\" corresponds to the first atom, \"feature 1\" corresponds to the second atom, and so on also for bonds\n",
    "shap.plots.bar(explanation, max_display=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the SHAP values for atoms and bonds\n",
    "shap_values = explanation.values[0]\n",
    "atom_shap_values = shap_values[:n_atoms]\n",
    "bond_shap_values = shap_values[n_atoms:n_atoms + n_bonds]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAIAAABUEpE/AAC87klEQVR4nOzdZ1xUx9cH8LOFpXdUmoqIgl3E3hUwxtgV1ChqLBg1aoqKMVFjSQRjrDEGjMZuxGhiiQ01xl7Aih1RpKMICAILuzvPi0nus38ERLmwgL/vxxfc2dm7cxGWs3NnzpEwxggAAAAAxCPV9QAAAAAAqhoEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAAAiQ4AFAAAAIDIEWAAAAPB6aWlpERERmzdvbteunYODg4GBgYWFxaxZs3Q9rgpKwhjT9RgAAACgAlGpVE+ePImOjr5169bt27f5F4mJiYV23rhx46hRo8p5hBUfAiwAAIB3Wnp6+sOHD7XDqdu3b+fk5BToZm5u7uLi4uzsrFQqa9eu3alTp2+++eb27dsymSwiIqJZs2Y6GXyFhQALAADgHZKQkCBMSvEvoqOjX+1mZ2fXqFEjZ2fnhg0b8i/q1KkjkUi0+2RnZzs4OKSnp7dq1erMmTMKhaK8LqISQIAFAABQNWVkZERFRfEQiodTd+7cyc7OLtBNX1+/bt262uGUm5ubsbFxSV7i/v37Xl5esbGxkyZNWrNmTRlcRGWFAAsAAKAqeHVq6tGjR6/+lbe0tBQmpfgXTk5OUunbb3q7evVqhw4dcnJyQkJCxo8fX7qLqDoQYAEAAFQySqUyKipKO5y6e/fuy5cvC3RTKBSOjo7a4VSzZs1MTU1FH8+WLVtGjhypp6d3/PjxTp06iX7+yggBFgAAQIWWlpamvZvv9u3bjx8/1mg0BbqJPjX1RqZNm7Zq1SpbW9vw8HAHB4fyedGKDAEWAABARZGXl/fgwQNh7fmtW7euX7+elZVVoNurU1NNmzY1MzPTyZg5lUrVo0ePv//+u23btidPntTX19fhYCoCBFgAAAC68eTJkydPnpRkakp7N1/Dhg3d3NxkMplOxlyM1NTU1q1bR0dHjxo1auPGjSV5Ck+4ZWpqWq1ataL6xMfHq9XqmjVrFtjD+PLly+TkZBsbmwKRZV5eXlJSkoWFhW4jTmIAAABQXhITE1u3bm1kZFQgXOAUCkXDhg0HDhz45Zdfbtq06eLFi+np6boe8hu4du2akZEREf3000+v7bx7924bGxuFQiGRSPr06ZOZmVmgw8OHDz08PKRSqVwur1evXkREhPDQt99+a2hoqFAoFArFZ599ptFoePuqVausrKz4Fsi+fftmZGSIeHVvBAEWAABA+alZs6YQTslkMg8PDz8/v8DAwNDQ0MjIyPz8fF0P8DWOHz9+5cqVYjps27aNiPT09E6ePFlMt5SUFAMDgy+//DI3N/f27dsODg4ff/xxgT7du3dv27ZtSkrKixcv+vXr5+TkpFQqGWMHDhyQSqXbtm1Tq9WHDh0yMDBYt24dY+zChQsmJiZhYWGMsYcPH9rZ2U2fPr20F/y2EGABAACUkxs3bvDQ6ttvv42KitL1cN7Y0aNH5XJ57dq1U1JSiun2xRdfEFGNGjViY2OL6hMUFFS9enUhoFyxYoWJiQmPn7i7d+8S0alTp/hhdHS0RCI5ePAgY2zAgAHe3t5CTz8/v7Zt2/Kvnz59KrR/8skn7dq1e+OLFAmKPQMAAJSTgIAAIrK3t589e3bdunV1PZw31rVr13bt2sXExAwcODAvL6+obkFBQe+//35ycnLfvn1fLbnDRUZGtm3bVi6X88NOnTplZWXFxcUJHW7evCmVStu3b88P69Sp4+joyKOue/fudezYUejZsWNH3k5ENjY2QvvLly+trKze8lJLDQEWAABAObl9+zYRTZgw4a3PoNFobt68ee7cuVe3FgqePHly9uxZ7WCFUyqVly5dCg8PV6lUBc5569at8PDwYs7J6enphYaGOjg4nDlzZubMmUV1k8lkW7durVu37tWrV4u62MTERGtra+GQB0ba9aSTkpIsLS211/Lb2NjwDgWeW61atfT09AKR3PPnz//4448BAwYUf0VlBwEWAABAeTh16lRMTIyDg8NXX331dmd48uRJs2bNWrVq1bdvX3t7+127dhXooFarR48e7eTk5OvrW6tWrUmTJrH/cgWcOXOmdu3a3t7e3bp1c3Z2vnLlCm+/fPly/fr1u3bt2rdvX0dHx9DQ0OLHYGtr+/vvv+vr669cuXL9+vVFdbOystqzZ4+xsfGWLVtWrVr1agcTExPtkIgX8NFOgmpiYlKgqs/Lly95hwLPffnypUKhMDAwEFry8/P9/PwaNWr00UcfFX85ZQcBFgAAQHng4cjo0aPfOsOCv7+/QqFITk5++vTplClTRo8enZSUpN0hJCRk165d58+fj4+PP3ny5IYNG7Zu3UpESqVy2LBh3bt3T01NTU1Nbdas2YcffsjzQUybNm3IkCFJSUkJCQkTJ04cN25cZmZm8cNo27ZtSEgIEX3yySeXLl0qqlvTpk03b94skUi++OKLv//+u8Cjjo6Ojx8/Fg4fPXrEG7U75OTkJCcn88O8vLyEhATewdHRkffnHj9+7ODgIOzKfPHixcCBA+Pj4/fv319ueVYLoavFXwAAAO+OjIwMnprhwYMHb3eGpKQkiUSye/dufpidnW1mZvbjjz9q92nXrt2oUaOEw8GDB/PF4IcOHZJIJLw0IWPs+vXrRHT+/HnGmFKpVKvVvP3evXtEdOnSpZKMZ+LEiURkZ2cXHx9fTLdZs2YRkbW1dXR0tHb7iRMnpFLp7du3+eHQoUM9PDy0O+Tk5FSrVi0oKIgf7tixQyaTPX78mDH29ddf29nZvXjxgo+/UaNG/v7+vNvdu3cbNmz4/vvvp6WlleQqyg4CLGD5+fnjxo3r0KHD9OnTX01DAgAApbd27Voi6tat21uf4ezZs0SkHc106NBh2rRp2n1sbGy0E1AFBQU5OTkxxngRG+2ehoaGmzdvLvAS586dI6Jitv5py8vL69KlCxG1b99ee/dfAWq1+oMPPiCi5s2bv3z5UmjXaDSenp6Ojo5z58718fHR09M7ceIEY+z8+fPu7u7Pnz9njK1cuVIul0+ePHnGjBkmJiZCzoVnz545OTm5u7svWLCgY8eO1apVi4mJYYydOHHCxMTE2tp6xowZAf8pybWUBdwiLA8ajSYyMvLq1atKpbKoPrGxsREREU+fPi3QrlQqr169GhkZWSC3r0ajuX37dmRkZDHnLImEhISaNWv+8ssvZ8+eXbp0qZmZWdeuXfmHGwAAEAu/Pzh27Ni3PkNKSgoRWVpaCi3W1tbatwjVanVqaqr2vjkbGxveISUlpcB+OisrK+Hum+Cnn37q2LGj9n26Yujp6e3cubNmzZrnzp377LPPiuomlUq3bNni4uJy7dq18ePHC+0SieSvv/6aOXPmo0ePHBwcLl261K1bNz6wrl276unpEdHUqVP379+fn5+fmpq6fv36JUuWCBd+6dKl/v37P3jwoEuXLleuXKlVqxY/5+TJk8eNG6fLO4MCXUV2744HDx40aNBAX1/fzMzMxsbm6NGjBTrk5eUNHTpUIpFUq1ZNJpN9/fXXwkPHjh2rVq2amZmZgYGBm5vb/fv3efvp06fr1KljZWVlbW1dvXr1w4cPv93Y7t69y1cFSiSSli1baq8QbN++/fr16zGhBQBQejz9lbm5ufYUjrZTp0598sknN2/eLOYkJ06cICLtPE9du3YtkJzT1NT0l19+EQ6XL19uZ2fHGPv+++9r1apVTE/G2Lp160xMTK5fv17iy2KMsStXrhgaGhJRSEhIMd3u3LnDC9f88MMPb3T+ygsBVplr3759+/btX7x4oVKpJkyYYG1tXSBzf1BQkLm5OU+M++eff0ql0r/++osx9uLFCxsbm3HjxqlUqszMzI4dO7Zp04YxplKpGjRosGjRIrVarVar/f39tXO1ldxff/1lYWFBRAYGBkK+3U2bNn3yySfCBx1DQ0MfH5+wsDChCgEAALypqVOnEtHkyZOL6jBs2DAi+uabb4o5SVRUFBGdPXuWH2o0mpo1a3733XfafRo3bjxz5kzhcPLkyfwPx86dOxUKBV+0xBjj01pHjhwRei5btszExOTvv/9+42tjbPPmzUSkp6cnJAUt1J9//imRSGQy2aFDh97iVSodBFhl68GDB0TE0/Yzxp49e6anp7dt2zbtPo0aNZoyZYpw2L179yFDhjDGduzYoaenJ2TL5Z9d7t69yxjLzs4WIp6LFy8SkTC5VRIajSYwMJDPoPr6+r66EjAnJyc0NNTLy0vYlOHm5hYYGJicnPxGlw8AAEqlkid5KqrCTFpamqGhoVQq5Su4i9GyZcuRI0fyrw8ePCiVSgukg1+wYEGtWrV4+cLU1FRbW9vly5czxl68eGFmZrZy5Uqhm7m5eVZWFmMsMzNzyJAhjo6OJVzbXigeQdra2sbFxRXTbc6cOURkZWVVGbPYvykEWGXrr7/+IiLtOeFGjRppf0bRaDT6+vrbt28XWmbPnu3u7s4Ymz9/foMGDYR2nvNj//79BV7i0KFDUqm05PUsMzMzBw0axG8Lzps3r/ipqXv37gUEBNSoUYOHWQqFonfv3qGhoRW/WhYAQAWxY8cOImrRokVRHXiaqPfee++1pzpy5IhCoejZs+e4ceNMTU0/+eQT3t6xY8elS5cyxp49e+bs7NygQYPJkyfXq1evYcOGwl+HpUuX6unpjRgxYsiQITKZjN8fzM3NbdSoERENHDjQ/z98sfkbyc/P5yuo2rZtm5ubW1Q3tVrdp08fImratCkP76qwCrAKrEpLSUnR19fnpcW5AmsS09LSlEql9qJFKysrYU2idruBgYGxsXGBlCdE9PPPP/fs2ZPf236tqKiodu3a7d6928zM7M8///zmm28KLecuqF+/fmBgYHx8fFhYmI+Pj0ajOXDggK+vb+3atWfNmhUdHV2SFwUAeJe9dnn7hg0biu8g6NGjx/Xr19u3b29jY7N9+/bVq1fz9lGjRrVt25aIrK2tr1y5MmnSJGNj488///zixYvCX4cvvvji+PHjtWrVql+//rlz54SX46WmW7du7fwfc3PzN71GuVy+a9cuZ2fnCxcuFJOnnldobtiw4Y0bN/hU3Ju+UGWi6wivituzZ49EItHev+ru7v7ll18Kh/n5+TKZ7Pfffxda5s2b17BhQ8bY7NmzmzVrJrSrVCqpVLpr1y7t869YscLCwuLevXslGcyhQ4d4xObq6nrnzp23uJyEhITAwEAXFxf+wyOVSjt06BAcHFzUsk0AgHfco0ePpFKpoaEhzzvwqsuXLxORtbV1MRM/lcW1a9f4hIJ2qohX3b17l8dwgYGB5Ta28ldpZrDyWX5ifmJifmIeK7K6ZAXk6OjIGHv48CE/VKlUMTEx2jtg5XJ5jRo1+NJF7uHDh7xDzZo1Y2Ji8vPzeXt0dDRf0sgPGWOLFy+eO3fuwYMH69evX/wwGGNBQUG9e/dOS0vr3bv3xYsX3dzc3uJy7OzsAgICHjx4EB4e7u/vb2hoePbs2QkTJjg4OEyYMOHq1atvcU4AgCpsw4YNGo1m0KBB2ncktPH5rZEjR+rr65fv0MTXrFmzdevWEdG0adP++eeforq5urru3LlTJpPNnj374MGD5TjA8qXjAK/EzmadpQiiCDqaUTDNQUWWn59va2v7+eef80P+I1Vgcd+YMWMaNWqUk5PDGEtKSrKwsFixYgVjLDExUaFQCCviZ8yYYWtrm5eXxxh78eLF4MGD69ate+PGjdeOIScnx8/Pj4gkEklAQICQsbf00tPTg4ODPTw8hB8nDw+PFStWpKamivUSAACVl1qt5vmZitqdl52dzXdzv2lyhIrsiy++IKIaNWoUn7B0/vz5RGRpafnWqe0ruAoRYCXmJf6Q/EOvqF4NbzWscaOGS6RL53udFycujs37//+bShpgsf+y+/v4+Pj7+xsZGQkbaD08PNavX88Ye/z4sa2trYeHx6efflq3bl13d3fhjtusWbOMjIzGjx/v6+srk8l27NjBGMvIyKhfv75EIhk8eLCwJvHixYuFvvqTJ094AGRqavrHH3+U0TVGRkYGBAQItc0NDAyQ3AEAgE/PODs7F/VmuGnTJiJq27ZtOQ+sTKlUqvfff5+I3N3ds7Ozi+qm0Wh8fHyIyM3NreT7tCoRCdPpEjNGbFHiosDkwGxN9quPGkuNAx0CP6n2CRGde3muw70ORHTU5ai3mXd5D7R0IiIidu/enZub6+npySsGENHy5cs7dOjQunVrIkpOTt60aVN8fLyrq+vo0aO1F8X/9ddfx48fNzAwGDhwYMuWLYnoxYsXvOSCtj59+jRs2LBA4z///OPr65uSklKvXr0///zz1Q7iUiqV+/btCwkJOX78OP+5ql+//rBhw8aOHSvc2QQAeHcMHjx49+7d33333Zdffllohy5dupw6dWrdunXjxo0r57GVqefPn7du3frhw4d+fn48S1ahsrKy2rVrFxkZ2a9fvz/++KP4TVeVjw6DOw3TjHw0ks9Lya7I+j/s/2PKj7vSdm1K3fTJk0+srlvxh5YmLWWVeQZLV4KDg3mpgV69epWk5mVYWNjYsWNFmXN68uRJYGBg7dq1+c+YTCbz8vIKDQ3l9zcBAHQiNjb26tWrxRSoyMjIuHLlSmJi4qsP3bt37+bNm6++icXHx9+8ebPQjT7Pnj3T19eXy+VF1UKOioqSSCTGxsZVcv7m+vXrxsbGRCQk3ypUdHQ0v/uxcOHCchtb+dBlgPVTyk88ZnK44RDxMqLAoyn5Kd3vd69zs86N7BsMAdabyMnJGTVqFL3JoqsffvhBLpcTkXZGrlJSq9U8uQOP80hrjbxYLwEAUBJZWVkffPCBRCIxNzc3MjJau3btq32CgoL09fXNzc0lEsmQIUOE3d/R0dFNmzaVy+XGxsa2trZ8hp4xFhsb27lzZ319fRsbGyMjo1f3zS1dupSI+vTpU9SoAgICiGjMmDEiXWWFs3v3bolEIpfLi0+sdfToUZlMJpVKX030WKnpLMDKVmfzOSr9K/qROZGF9slSZz3N/7foEgKsEoqNjW3VqhURmZiYaGd/KEpOTs7o0aPfKBp7U4mJiStWrGjSpIkwb+rh4REcHFzls8wBQAXx+eef29nZ3b17V6PRrF69WiqVXrt2TbvD5cuXJRLJ5s2bGWNXr161tLQUJlQ6d+7cunXr58+f5+XljRs3Tih39uGHHw4cOJDPh61evVoulxf49MhXZfz555+FDik/P9/e3p60St9USbNmzSIia2vr6OjoYrp99913RGRqanrr1q1yG1tZ01mAtSl1Ew+YpsZOLUl/BFglcerUKZ513cXFpfiiodybRmOlxJM7mJiY8DDL3Nzc398/PDy8rF8XAN5lGo3G2tr622+/FVrq168vbO7mxo8fz2v2cTNmzKhbty77L8nO4cOHebt2ubP8/HxhBXdeXp6wD4k7d+4cEdWoUaOopRF79+4lIldX16q9GUitVvOVx82bNy8mY6JGoxkyZAj/hvA6P1WAzvJgncg8wb/ws/LT1RiqmJCQEE9Pz+Tk5J49e166dKlx48bF9z99+nTLli0vX77s4uJy/vx5Xj+nTPGJq/j4+E2bNnl5eWVkZISEhLRs2bJRo0ZBQUHPnj0r6wEAwDsoNTU1NTW1Q4cOQku7du3u37+v3ScyMrJ9+/bCYdu2bR89epSfn8+7Cc+1trauX78+b5TL5YaGhrw9MzNTrVZXr15dOAPPbjV69GhhjUQBvMO4ceOq2sru/yWVSrds2eLi4nLt2rXx48cX1U0ikfz6668tWrS4d++en5+fRqMpz0GWEZ0FWOEvw4nIQGrQ3LC5rsZQZSiVyrFjx06YMEGlUgUEBBw4cKCojHaCN43GRGRmZjZy5MiwsLDbt28HBARUq1bt9u3bs2bNcnR09PX1PXbsGKvaxRMAoHwlJycTkfa7YoGSZbyPlZWVcGhjY6PRaFJSUpKTk/X09IR5d/5QYmJigZcICQlxdHTkxWqIKCsrKzQ0lIj4AoxXJSUlHTp0SC6XjxgxojSXVilYWlru37/fzMxs+/bty5YtK6qboaHh7t27bWxs9u/fv2DBgvIcYRnRWYCVokohIieFk1wi19UYqob4+PguXbps2LDB2Nh4586dgYGBMpmsmP5vEY2VkQYNGgQGBsbGxoaGhvbu3VulUu3atcvb25sXOoyJidHJqACgiuHF+LKz/z8ZUFZWVoFye2ZmZi9fvtTuQETm5uZmZmb5+fl5ef9fQSQzM5OnBhWcPn16wYIFq1evFjLs7Ny5MzMzs1OnTkXVzNi4cWN+fn7fvn1tbW1LeXWVgpub2+bNmyUSycyZMw8fPlxUNycnp99++00uly9YsGDXrl3lOcIyoat7k4orCoqgVndalbB/gTVYqfmpUblRr31WlXfmzBn++1mzZs2SLGaKi4tr06YNERkYGPDlnBVHXFxcYGBgnTp1+E+mVCpFcgcAKL28vDw9Pb2tW7cKLV5eXqNHj9bu07dvXx8fH+Fw1apVVlZW7L9CgULxVpVKZW1tvXr1aqHngQMHTE1Nf/75Z+2ztWvXjog2btxY1JB44PXXX3+V7soqmTlz5hCRlZVVgXImBXz//fdEZGJiUpKVxBWZzgIsw6uGFEEedzxK2L9AgLU4cTF/evDT4Cz1O7oZLTg4WKFQEFGXLl2Sk5Nf2/9NozGd4Mkd/Pz8hMUNtra2U6dOLUlRIACAQg0ePNjT05Pvko6KipLL5QWCm82bN5uYmCQkJDDG8vLyWrVqNWHCBMaYWq12dnaePn0677Znzx65XB4XF8cY02g0gYGBZmZmBXYI3blzh/6bEit0MCdPniQiBwcHlUpVBtdacanV6j59+hBR06ZNi99Fzm+t1qtXryRJHCssnQVYdjfsKILqRtYtYf8CAdZX8V8ZXTXiLZbXLD958smVl1fKcrwVS25urpD219/fPz8//7VPEaKxzp07lyQaK0Cj0Wzfvv3DDz8cNmzYr7/+Wmg2h/Dw8AkTJvj4+MydO1e7HGFubu6yZct8fX1HjRp15MgRoT0/P3/9+vV+fn6jR49+9ZzPnz8PDg5u1qyZMNvK18gXkyQQAKBQV69eNTEx6d69+/Tp02vWrNm1a1f+hjN+/Hi+nTA3N7dFixbOzs4zZ87s0KGDtbW1MMuyfft2qVT64YcffvLJJyYmJp999hlvHzBgABF16tRJKFm2c+dOxtjnn39ORDw+KxQvDvv111+X+WVXPC9evODZKwYOHFjM9sns7GxeucTb27vyhqE6C7Da3G3DE7i/VBe5b1Pbq2kaMlQZm1I3ed334u0UQQ1vNQxMCnyW/6wsB6578fHxfCmlgYFBMVPQAqVSKezd8Pf3f7s7bl9//bWBgcGsWbPmzJljYmIydWrB5Bpnz55VKBSDBw9esmRJ48aNGzRoIHx669Wrl729/bfffjtx4kSJRLJp0ybe3r9//3r16i1ZsmThwoUWFhbTpk0r9KV5cgdTU1N+CWZmZn5+fmFhYW9xFQDwznr48OHcuXMnTZoUHBwsJBHdunWrMP/08uXL1atXT5w4cdGiRQWqFF+4cGH69OlTpkzRrui6cOHCgP+1b98+pVLJ9xJeunSp0GGkp6cbGRlJJJLib5NVYXfv3uUL4AIDA4vpFhMTU61aNSKaPXt2uY1NXDoLsKY8mcKjoiMZR17fu9g8WLdzbgfEBVS7Xo130L+i7xPtE/YiTMOqYHKR8PBwXpvd0dGxqF9gbfHx8Xw1gIGBwa+//vp2L/r06VOFQiHkKd62bZtMJouJidHu061bt549e/JPJCkpKUZGRmvWrGGMHT9+XPu95vPPP7e3t1er1Tk5OV999ZUwl7ZmzRp9ff1ipuKys7NDQ0O9vLyELc0NGjSYMWPGvXv33u6iAABEx5dmN2nSpKgOP/30ExF5enqW56gqmn379kmlUqlUWvwqtNOnTysUColE8ttvv5Xb2ESkswDrcMZhHg/5RPu8vncJEo3manJDn4f2juotuyLjPWverBkQF/BY+VjUgevS5s2b+cqkTp06JSUlvbZ/RETEG0VjRdm7d69EIhGqZeXm5hoYGGzZskXooFKp5HK5dkv//v0HDx7MGJs7d66rq6v2kIjo9u3bBV7i0KFDRFSS2+23bt36/PPP+ScbrlatWitWrHjrqwMAEEvPnj2p2Op7Hh4eJGpRskpq/vz5RGRpaVl88bQVK1YQkaGhYUREwXp6FZ/OAiw1U9eLrEcRJImQHEg/8Nr+Jc/kHpsXG5gUWOdmHd5fGiH1uu8V+jw0T1OJN6Pl5+fzqlUlv823ZcuWN4rGirFmzRpra2vtljp16mjP7sbFxRHRmTNnhJZPP/20Xbt2jLGPPvqoR48eQntqaioRvXqDb+7cuS4uLiUfkkqlOnLkiJ2dnRBmrVu37o0uCgBAXLGxsTKZTKFQPH36tNAO169fJyILCwshBfw7S6PR+Pj4EJGbm1vxta7HjBlDRE5OTkV9VyssneXBkpJ0ba21EpIwYoMfDV6ful5D/5O5lRH7J+ufZSlFJiUriqOeY0CNgKjGUWH1wvys/PSl+scyj/k+8q0VWWta3LSbOTfFu4hy8uzZsx49evBCpOvXrw8ODi4qNTCnUqlmzZrl5+eXk5Pj7+9//PhxXj/nreXm5urr62u36OvrayeVycnJISK+iL5AhwLPNTAwoP9NSENE0dHRK1eu5Dt4S0gmk/Xo0SMhIeHChQt8a+TatWvf6KIAAMS1YcMGtVo9cOBAGxubQjusW7eOiLR3Sb+zJBLJhg0bGjdufPfu3ZEjR7Ki80uvWbOmdevWjx8/HjZsmEqlKs9BlpZu47sVySukEVI+1eQc6TzxycTFiYu/T/p+4pOJfH5LfkWelJfESlGL8LnqefDT4Ga3mwlr4Xlyh0x15diMduXKldq1axORg4PDhQsXXtv/6dOn3bp1IyIejYkyhu3btysUCu0dH9bW1tp5X3hSPu276WPGjOnVqxdj7PPPP+dTWdzjx4+J6PLly0JLXFxcvXr1xo8f/9YFub788ksiqlat2ts9HQCg9DQaTd26damwGXouNzeXB15Xr14t36FVXNHR0dbW1kQklNYuVEJCAi+MPWPGjHIbW+npOMBijB1IP+B6y1WIfgr8a3239b3ce0yMYs/hL8P9Y/xNr5ny85hdM/N75Bf2okJvRtu6dSv/oNOhQ4fExMTX9n/TaKyErl69Slol3yMjI4no9OnT2n1q1649c+ZM4dDFxYVnjtm8ebOBgYEwA7xp0yaFQiHU8jxz5oy9vf3HH39caN6HEjp48CARyeXytz4DAEApHT16lIicnJyKejfbtm0bEXl4lDT74zvi6NGjMplMKpXu37+/mG58ozoRvfVurfKn+wCLMZavyT/+4viX8V8Oix7m/cC7d1TvsY/HrkhecSvnltDnifLJ3IS5cxPmPsx9WJrXylZnhz4P9brvJYmQ8Eirwa0GgUmBKfkppb4OMRVYdCVsKi7Gtm3beKGGEkZjb6Rt27Zt27aNj49PTk729PRs2rQpfxMJDQ19/PgxY+y7774zNzc/efJkdnb2okWL9PT0eO7jnJyc6tWrjx49Oj09/fbt287OzqNGjeLnXLlypYGBweLFi5//5+1SSGRnZ8vlcqlUimUNAKArQ4YMIaIFCxYU1aF79+5EJGzHBsF3331HRKamprdu3Sqm25o1a4jIwMBA+x5IRVYhAiyduJtzNyAuoPr16trJHfal71NpdJ/T7NmzZ56envw2X0nWbr9FNPamHj9+zOvJSySSVq1aCfs+iIiX3MnPz584cSLfUlu9evVdu3YJzz179qyLi4tEIpFKpf379+ezWXxWrIDDhw+/3fBcXV2JCNneAUAnUlNTDQwMpFJpgfw1gujoaKlUamhoWKlTk5cRjUbDw1NXV1fh/kaheE7HWrVqpaRUrDmRQr27ARan1Ch3pe3q+aCnsBSs96ne8+fPf/Lkia6GdPXqVScnJyKyt7c/f/78a/trR2MhISFlOrZnz54V+LHOz8/XXjuVnZ0dFxf3auJdjUaTkJBQ/FaR0ujXrx8RhYaGltH5AQCKwbMJvP/++0V1+Prrr4nIz8+vPEdViWRnZ7do0YKI+vTpU8yKkby8vE6dOhFRx44dK36Z2nc9wBLE58UHJgU6Rzq7+7vTf5WGN23aVM53nXbs2MFv87Vr145XxSretWvXeHVkOzu7c+fOlcMIK6aZM2e+dpkkAEAZ4UW9ChQlFKjVap6S8OTJk+U8sErk0aNHfBPAvHnziumWmJjo4OBARAXKdVdACLD+h5qpj4YdHTp0qJBZoFq1ap9//nnxN4ZFoVKphNt8fn5+JQnshGjMw8OjqHnpKmPevHk1a9bcsWNHoY+uX7+eiEaMGFHOowIAuHTpEhFZW1vn5uYW2uGvv/4iImdn57feK/2OOHbsmFwul0gkxd+OOH/+vFwuJ6KxY8eW29jeAgKswqWlpQUHB7u7uwvLg3il4RcvXpTFy6Wmpnp7e/OtcMWXZ+J4NMaLxowYMeJdWNzNczF88803hT569uxZImrZsmU5jwoAYMKECUT0xRdfFNVh4MCBRLR48eLyHFUl9f333xORiYnJzZs3i+k2btw4/qd5w4YN5Ta2N4UA6zXCw8OnTp1qZWXF/y8NDAx8fHzCwsJE/CBy/fp1Z2dnIrKxsTlx4sRr+79pNFY1bNy4kYiGDRtW6KM8QbypqSk+IAJAecrOzrawsCCiom50JCcn6+npyeXy+Pj4ch5bJTV69GgiqlevXvEbAho2bEhENWvWLK9xvTEEWCWSk5NToNKwq6trYGCgUKv4re3cudPY2JiI3N3deb6D4r1pNFZlXLhwgX+XiurAqxPGxcWV56gA4B3HP/tpp1MugE/J9O3btzxHVallZ2e3bNmSiLy9vV/dMiXgtzWMjY3Lc2xvBAHWm7l37968efP4ckUikslkXl5eoaGh+fn5b3oqjUYTGBjII7bhw4eX5DZfaGjoG0VjVUlaWhr/XSpqjqpjx45EdPz48XIeGAC8y/imtl9++aWoDnyiZe/eveU5qsru8ePHNjY248aNKybrEC+S9sEHH5TnwN4IAqy3oVKpwsLCfHx8hJqA9vb2AQEBUVFRJTxDRkZG3759S36bTzsa+/DDD9+FRVev4hUVi8qgwW/Jr1mzppxHBQDvrHv37kkkEhMTk6KW5545c4aIbG1tK35OgYqm+DuqvOpaBU9/qLNiz2Xk2LFjI0eO7NOnz/z581+8ePFqh4cPH06ZMqV3796TJk26d++e0K7RaH755ZdBgwYNGjTol19+0Wj+v/L006dPFy5cqF2KWJi4iomJCQwMdHFxSUhICAoKql+/fseOHUNCQgoUMy7g3r17bdq02bdvn7W19eHDh4XNg0V58eLFgAEDZs2aJZPJAgMDt23b9m4WCnVzcyOiu3fvFvoozzWq/X8KAFCmeL3XIUOGmJqaFtWBiEaPHi18GocS4sUHi/Lbb78RUefOnZs0aVJeI3pzuo7wxLR7926JRDJx4sTly5fXq1evVatWBe7cPXnyxNraunv37j/++GPPnj3Nzc2FjOSffvqpiYnJggULFixYYGJiMm3aNMaYRqOZNGmSiYmJo6NjnTp1innp8PBwf39/fv+OiCwsLPz9/a9cufJqz/3795ubmxNR8+bNHz169NqLunfvXoMGDYjI2tr62LFjJf5mVEF8q86qVasKfXT//v1E1KNHj3IeFUCV8ezZs1mzZr3//vsjRoz4+++/X+2gUqnWrl3br1+/fv36hYSEaCeEjIyMnDBhQo8ePSZPnqw9l69Wq/fv3z969Ohr166VwyWUp/z8fDs7OyIqKgdhZmYmD7x43TAQEf+8feDAAV0PpDhVKsCqV6/euHHj+NcPHz6USqUFcmlMmTKlbt26PFVJfn5+48aNx4wZwxiLi4uTyWS85AtjbPPmzTKZjC+XPnLkyLNnz37++efiAywuPT09ODiYl5ThPDw8VqxYkZqayv67zSeVSolo6NChL1++fO0JhWisWbNm0dHRb/btqHKWLVtGRJMnTy700fv37xNR7dq1y3dQAFVETk5Oo0aNmjRp8uOPP44fP14qlR48eLBAn8mTJ5uZmS1evPjbb781MTH57LPPePvdu3dNTU179+69du1aT09Pa2vr2NhYxtjx48fd3Nxq1aoll8t37txZ3pdUxv744w8icnNzK2phaEhICBF17ty5nAdW5f3zzz9E5ODgUMwS+Iqg6gRYCQkJRKS9sa59+/YF/hg3a9Zs5syZwuH8+fNdXFwYYzt37lQoFMLCpuzsbD09Pe23gxIGWIIrV65MnjzZ0tKSh1lGRkbDhg3r1q0bEfHbfK89w1tEY1UeT9bn5eVV6KMqlUpfX18ikeB7Be+gp0+flvIMISEh+vr6Qp34YcOGtWjRQrvD48ePpVKpkOx348aNcrmcF5wYOXJk8+bN+V+73NxcZ2fnTz/9lDEWFRUVERHBGLOwsKh6AVbv3r2J6IcffiiqQ5s2bYho06ZN5Tmqd8HIkSOJ6KuvvtL1QF6j6qzBiouLIyJhfx//Oj4+vkAf7Q61a9fm01RxcXHVqlUTFjYZGhpWq1atwHPfiLu7+48//piYmMiTO+Tk5OzYseP69esWFhaHDh167aKrzMzMQYMGzZo1SyKRBAYGChnb33HFr8GSyWR169Zl/01lAbw7Dh06VLt27aCgILVa/dYnOX36dLdu3fjOLCIaOnTolStXsrKyhA5nz55VKBQDBgzghz4+PkR07tw5Ijp16pSvr69MJiMifX39AQMGnDp1iojq1q3LC8xVPUlJSYcPH1YoFCNGjCi0w61bty5evGhubj548OByHlvVlpGR8fvvv0skEp4uqyKrOgGWUqkkIoVCIbTo6+vn5uZq98nNzS3QgdcqViqV2u38oZycnFIOSV9fn2clffDggbu7+/Pnz7/44gueI7QYDx48aNu27R9//GFlZVWSaOzd4eTkZGBgEB8fr/2mr634CAygqjp27Fh2dvasWbO6du361vs8Cnz+5F9rf86Mi4urXr26UEbMyMjIxsaGf0ZNTEws8Fz+ibcK27Bhg0ql6tu3b/Xq1QvtwJe3Dxs2DB+PxbVjx47s7Oxu3bq5uLjoeiyvUXUCLL7j4OnTp0JLSkpKgW0I9vb2z5490+5ga2srk8ns7e21n8gYe/r0KS8nKYq6desOGzaMiLRfvVAHDx5s3br17du3mzZtevny5ddGY+8UqVRar149xlhRf0KwkRDeTT/88MNff/3l6Oh45syZ5s2bf/PNN/n5+W96kry8PO2dbvwzp/ZnVKVSWWArnEKhUCqVarU6Pz9f+yF9fX3+ibeqYoz9+uuvRDR27NhCO+Tl5W3durWYDvDWeORaKb6xVSfAqlmzZrVq1f7++29+qFQqz58/37hxY+0+LVq0EDoQ0d9//807NGzYMCsr6/Lly7w9PDw8KyurwHNL6bWTK4yxoKCgPn36pKen+/r6njt3jmdsB23Fh1AIsOCd1atXr8jISH9/f6VSOX/+/FatWl25cuWNzmBnZ1fgAyoRaX/OLPABlX8Qtbe3l8vl1atX135ucnKyiB9QK6CTJ09GRUU5OjoW9Rl47969T58+bdKkCc9IDmK5efNmeHi4hYVF//79dT2W16s6AZaenp6/v/+SJUvOnz///PlzvsSS3x0/ePBgeHg4EX3yySfHjx8PCQl58eLF5s2bDxw4MGnSJCJq2bJl69atp06dGhMTExMTM3Xq1LZt23p4eBBRTk5OWlpadna2RqNJS0vLzMx8u+G99m9/VFTU/PnziWjx4sW//fabkPEBtPE4tahvI24RwrvM3Nw8ODj45MmTLi4u169fb9u27axZs0o+k+Th4XHq1ClhFdfff/9tZ2dnbW2t3SEjIyMiIoIfXrhwIScnh2chatSoUYHPrhU6O1Gp8UmUMWPG8GVnRXUYP358uQ7rHbBu3ToiGjFiROW48aqz5fVlIDc396OPPuIz2/Xq1fvnn394e+vWrYXtxGvWrOGVmy0sLJYtWyY8NyYmpkuXLkQkkUi6desmpAufO3eu9rfrrTfc5ufnKxQKqVRazB63HTt2vLovGrRt2bKFiHx9fQt9lJfTMTIy0k7PA/CuefnyZUBAAN+D3Lhx44sXL5bkWSkpKUZGRp9++unTp0+PHTtmYWGxaNEixtjjx483bNjAf6c6duzYtm3b6OjoqKioli1bdurUiT939+7dcrl848aNz58/X716tVQq5W+/Go3m4cOHDx8+NDMzW7169cOHD3NycsrsustJenq6kZGRRCIpqnRHbGysTCbT19cv/dZO0KZUKm1sbIio0ByTFVCVCrC43Nzc9PT0Yjqo1ernz58Xmj8jKysrKyurjAbG84VWvWx75enSpUtE1LRp06I68D1QMTEx5TkqgAro7NmzfE5XLpdPnTq1JO9sR44c4SsTDA0Np06dyt8kd+/eraenx0vCxcTEdOvWTSKRSCQSb29v7WImS5cu5YlpqlWrJhTme3U/SlE5OSuRH3/8kYrOF8MY++abb4ho2LBh5Tmqd8H27duJyMPDQ9cDKakqGGBVWHx782+//abrgVRiL168kEgkBgYGReWX49OQR48eLeeBAVRAOTk5AQEB/DZW3bp1tdMEFiMjI6P46vXZ2dmFlkPVaDTPnz9/y7FWHu7u7kQk5AMrQK1W165dm4je8cIbZcHT05OIfvrpJ10PpKSqzhqsig9LsEvP1NTUzs4uNzc3Nja20A6vLsNSq9W//vrr6NGjP/744+PHjxf6rLNnz37yySejRo1au3at9varzMzMJUuW+Pn5ffHFF5GRkUJ7Xl7e+vXrx4wZM2XKFJ7+FKACMjAwCAwMDA8Pd3d3f/jwoaen54QJE167kNTMzEwulxfTwdDQsNByqBKJRMiuXFXduHHj6tWrVlZWRS2yPnbsWExMTJ06dXhmaRDL48eP//77b0NDw6FDh+p6LCWFAKv8IMASxZuWfB4zZswXX3xhZ2fHGOvRowdfI6nt999/79SpU2ZmZs2aNefPnz9w4EDenpeX16VLl3Xr1tWtW/fBgwctW7a8cOECEanV6vfff/+XX35xc3NTKBQ+Pj5LliwpiysFEEXz5s0vXrwYGBiop6cXEhLStGnTsLAwXQ+qsuLVb0aMGGFgYFBoB2H9O18DB2LZsGGDRqMZPHhwZQridT2F9g45f/48ERWoPgFvauLEiUS0fPnyQh/l80menp788OrVq0QkbB2YPXu2tbU1X03CaTQaJyenCRMm8EMeQvE7Kb/88otCoeDbHTQaTc+ePbt168YYS09P//rrr/Py8vhTZs2a5ebmVhZXCiCuGzdutGrVir/z+/j48BqpUHI5OTn8r/vVq1cL7fDs2TN9fX2pVIploOJSq9U8k+3Jkyd1PZY3gBC7/AgpBhhjuh5LJVb8RGCBPA4nTpywtbV97733+OGoUaNSU1OvXbsm9H/48OHjx4+Fkgtt2rRxc3PjdxJPnDjh6elZs2ZNIpJIJH5+fqdOncrPzzc3N1+4cKGQVjExMVF7KztAhdWkSZNz586tWLHCyMho165djRo14uWKoYR2796dlpbWqlWr5s2bF9rh8ePHderUee+997Tz2kPpHTly5MmTJ87Ozp07d9b1WN5AcTfaQVwWFhY1atRITk6Oi4vjf7bhLRSfCksop5OZmWlqahobG+vk5CTM1depU0cikRSo/sHbhZY6derwxtjY2KZNm2q3q9XqpKQk/n+XkpKyffv2CxcuXL16NTQ0VPzrBCgDcrl82rRpvXv3Hjdu3MmTJwcOHOjj4/PTTz/x3e9QDI1G89NPP1GxOcQ9PDzu3LmTnp5efsMqdyqVat26dadOnVIoFAMHDuzXr9+rfU6cOLF169bs7OxWrVpNmjRJWLGXkZGxevXqGzduWFlZjR07VphPzc3NXb9+/fnz5w0MDN57771BgwYVuMHKb7yOGzdOIpGU8fWJCTNY5QrLsEqv+DVYQjkdXvI5OztbKJ1GRHK5XC6Xa28dz87OJiLt5RSGhoa8Q3Z2doF2IhKeq1Qqnzx5kpWVpVQqk5KSxLs+gDLHdxQGBwebmJjwqazNmzfrelAVV2xsbFBQkIuLy71790xMTNq0aVN8fwsLi3IZl26MHj16zpw5DRo0sLKyGjx48MqVKwt0CA0N9fLykslkTZs2XblyZZ8+ffhNG6VS2blz561bt7Zs2TI9Pb19+/YnT54kIpVK1aNHj9DQ0NatW9vZ2Y0dO5bn3BY8e/bswIEDcrl81KhR5XWVItHxLcp3jL+/PxGtXr1a1wOpxNRqNc/hm5aWVmgHXrt+69atjLF58+Y1btxYeIhnItXePs3LiWgnDOzUqdOUKVMYY7179x41apTQztcFv5pibdGiRTY2NkWljQCoyB49euTl5cX/FvTu3ZtXbgYuMzPz119/7dSpkzBrYmpqSkTNmjUru3SJFRxf1Xro0CF+uHDhQnNzc+3ksXxV68SJE/nhjRs3hP6//PKLvr6+kDutX79+7dq1Y4y9ePHi22+/FTKDzJ07t27dutovunTpUiLigVrlghmscoUZrNKTSqX169cnIj5H9Srte4hNmza9e/euUCXt9OnTEomEd+Dq1q2rp6d3+vRpfpidnX3lypWGDRvy85w5c4b9t2DuzJkz9vb25ubmBV6uRYsWz549e/78uYjXCFA+nJycjh49GhISYm5ufuDAgdGjD2zapOsxVQARERETJkywt7f/6KOPTp8+bWBg4OPjExYWFhcX17Bhw+vXr48cOZK9k0tpT548Wb169R49evDD4cOHZ2RkaFe9fPz48ePHj3mROiJq0qRJ06ZNeRmlkydPdu/e3d7enj80YsSICxcu5Obmmpqazp49W8gM8vjxY54vWrBhwwaqJNWdC0CAVa54gIVieaVU8pLPffr0qVGjxueff/7y5cvExMQ5c+Z88MEHDg4O2dnZ+/fvT09PNzMz8/Hx+fbbbx89epSbmxsQEKCnp+fj40NEo0ePjomJWbJkiUqlunLlypo1a8aNG0dEsbGxzZs3P3v2LGPs5cuXISEhdevWxRIWqKQkEsn48eMjIyN9fSdcuTJ+9Gjq1YuKSDNXxSUkJAQFBdWvX79ly5YhISGZmZkeHh7BwcHJycn8tpeZmdmePXvMzc337NnzbiZniYuLq127trBAqlatWlKplC9aFTrQ/65qdXJy4steY2NjeQpWoZ0xlpCQwA+TkpIWLVrUv3//iIiI4OBgodu5c+du375do0aNXr16leWVlQkEWOWq+AXaUEIlL/msp6f3+++/nz171tLS0sHBwdzc/JdffiGihISEvn378jP8+OOPdevWdXZ2Njc3/+OPP3bv3s13BTZq1OjXX38NCgoyNjZu3br1+++//9VXXxGRo6PjoEGD3nvvPTMzMysrq3v37u3atatyLb0EKMDR0XHnzp9//llqY0OHDpGbGwUFkUaj62GVC6VSuX//fl9f39q1a8+aNevBgwf29vYBAQH3798PDw/39/fndwY5V1fXLVu2SKXS2bNnHzx4UIfD1onc3FztVa0ymUxPT4+vZOVycnKIiFcE5vT19XmHAs/lK1yF56rV6szMTD09vbS0NO27E3x5++jRo4WN25WJbu9QvmvUarWBgYFEIsnMzNT1WCoxXpFq0KBBhT76ajkdtVr9+PHjxMREoY9arU5PT9deOJWcnPzo0aNXl1Ll5eU9fPjw1QIg2dnZt27devToUekvB6DiSE5mfn6MiBGxjh3Z3bu6HlBZioyMDAgIEKaf9fX1fXx89u3bV3ylIMYYX4VtaWn54MGD8hlqBbFo0SJXV1fhMCMjg4iOHDkitNy8eZOI7ty5I7R07dp18uTJjLH+/fsPHz5caD9x4gQRvZqMbenSpRYWFjxbId8MXuCElQgCrPLWuHFjIoqIiND1QCqxiIgIItJevV6Ag4MDEUVHR5fnqACqjH37mIMDI2KGhiwwkFWxLRzPnz8PDg7mJQW5hg0bBgYGPn36tIRn0Gg0fCGBm5tbRkZGmY62Qjlw4IBUKhUWqu/bt08ulyckJAgdXr58aWZm9vPPPwuHJiYmvHrg7Nmza9asqVar+UPz5s2rXbs2/1poZIwdPnyYiPg5eeGNzp07l/mFlQ0EWOVt0KBBRLRt2zZdD6QSy8rKkkgkCoWiqA+a3bt3J62tLgDwptLSmL//v1NZbduyW7d0PaBSU6lUYWFhPj4+wg0sS0tLf3//K1euvMXZMjMz+aflfv36aTQa0UdbMalUqjp16gwYMCA1NTU6Orpx48a+vr6MsaysrJ07dz579owxNmXKlJo1a964cePFixf+/v6WlpZ8murBgwcKheLrr79++fLlmTNnrKyslixZwhiLjY11dXU9cuRIXl5eWlpa7969XVxceMjVtm1bItq0aZNOL/rtIcAqb3wdz9y5c3U9kMqNZ/vUTq+gbdKkSVR0OR0AKKFDh1itWoyI6emxgACmVWWqMrlz505AQICwN00mk3l5eYWGhipLdz3R0dF8vebChQvFGmrFd/Xq1UaNGkkkEolE0qNHj5SUFMZYdHQ0EfFt15mZmTxTqEQiqVOnzj///CM8948//rC1tZVIJHp6euPHjxcKji1btszKykqhUEilUnd39xs3bjDG7ty5Q0Tm5uYvX77UxYWKAJncyxsyNYjCzc0tNjb27t27devWffVRfJMBRNGzJ928SXPm0I8/UlAQHTpE69dTy5a6HlbJZGS82LFj+8aNGy9evMhbGjVq9NFHH40YMaJGjRqlP3+dOnV27Njx/vvvz5s3r3nz5r17937tUx48ePDnn39mZ2d36tSJT7QX8OLFi9DQ0NjY2Lp16/r6+mrnOj5//vzx48flcvkHH3zQpEkTof327duHDx9WKpXt2rXr2rVr6a+reM2bN4+MjExOTtbX1xdSqtapUycvL4+nWjAxMfn9998zMzOzsrJ4OCU8t3///n369ElKSrKyshLSuxPRZ599NmXKlISEBAMDg+rVq/NGXld72LBhPPFhpaTrCO+dc+nSJSJq1qyZrgdSuX3yySdE9MMPPxT6KL+Lz2szA0DpnT7N6tdnREwuZwEBLDdX1wMqmlrNTp9m/v6sZcsM/mfO3Nzcz88vLCysLF7uu+++IyJTU9Nbr7uNeujQIYVC0a1btyFDhhgYGMyYMaNAh5SUFGdnZxcXl9GjRzs6Orq7uwsZTYOCguRy+aBBg3r16iWXy3kiZcbYqlWrjIyMhg4dOnLkSAMDg4CAANEvUCeUSmW1atWI6PLly7oey9tDgFXeMjIyJBKJoaGh9rI+eFOrV68mIn9//0Ifffz4MRHZ2dmV86gAqrDsbBYQwGQyRsRcXJjWnZ+K4uFDNncuq13736VjUikbOjRg27Zt2qnGRafRaIYMGUJErq6ur1Z60O7m7OzMM5Qyxnbs2CGVSm/fvq3dZ9q0abVr1+Y1KuLj4y0tLYOCghhjCQkJ+vr6K1eu5N1mzJhhY2OTm5ur0WhGjhx5/Phx3r5x40apVPrqvrzKiBd4bdKkia4HUioIsHTAzs6OiLDDvzR44ZqidpdoNJriy+kAwNs5d441bPhv+OLvzypCwpmcHBYayry8mETyb2hVsyYLCGAPH5bTALKzs1u0aEFEffr0KeqT861bt4jo0qVL/FClUlWvXn3p0qXafVxcXL766ivhcMyYMZ06dWKMbd68mddI5e2PHj0iopMnTxb6EteuXRPrunTovffeI6JVq1bpeiClgkSjOvBqnszMzMzFixcPGTLk448/vnDhwqtPYYzt3LnTz89v+PDhmzdv1mhlAHzy5MnMmTN9fX2nT5/OVxpyT58+Xbhw4YcffjhlyhR+X7IqKb7ks0QiKb6cDgC8nXbt6No1CgwkuZxCQqhpUzp+XGeDiYigadPIwYF8fenYMdLXJx8fCgujmBgKDCRn53IahqGh4e7du21sbPbv379gwYJC+zx58oT+Wx5KRDKZzMXFhTdyjLG4uDihAxHVr1+fd3jy5Imjo6OxsTFvd3JyMjAw0H4ud/v2bblcXq9ePfGuTDfi4uKOHTumUCiGDRum67GUCgIsHSgQHOTn53fv3n3Dhg3u7u6ZmZkdO3bk0zPavvnmm1GjRtnb29epU2fy5MmfffYZb09ISGjVqtW5c+datWoVERHRqlUrfncsMTHR3d393Llz7dq1y87ObteuHc/qVmU4ODiYmJikpKQUVQQQ69wByoieHgUE0OXL5OFBjx6RtzdNmEAvXpTfABITaeVKataMWrakVavo+XPy8KDgYEpJodBQ8vKi8i+s4OTk9Ntvv8nl8gULFuzatevVDunp6UQkBElEZGpqyhu53Nzc3NxcExMTocXMzIx3yMjI0G4nIhMTE+3nEpFSqfz2228nTJhQiZeE/2f9+vVqtXrQoEGVvgSZrqfQ3kUrVqwgIqHe+JYtW+RyuXDH0NfX18PDQ7v/06dPFQrFmjVr+OG2bdtkMllMTAxj7NNPP3VycsrOzmaMKZXKBg0aTJgwgTF27969+fPnC9lZevToMXDgwPK4tnLE5+TPnz9f6KPz5s0jIu35dgAQV34+Cwxk+vqMiNnZsT///J9Hvb2ZszNzdmZr1xZ5hg8+YM7OzM+vRC+nVLJ9+5iPD9PT+/dWoJ0dmzqV3bhRqqsQ0ffff09EJiYmN2/eLPAQ/4irncvUw8OjwJp0MzOzX375RThcsGCBm5sbP62Qk5MxplarZTJZaGio0JKfnz9kyJBmzZpVgUURfLEaER07dkzXYyktzGDpQIHJlZMnT3bq1MnJyYkfjhgxIiIi4oXW58Fz587l5+cPHz6cHw4aNEihUPzzzz/8uYMHD+b7XRUKhY+PD69bXr9+/blz5wr7Y+vWrZuamlo+V1duir9LiLraAGVNLqeAAIqIoDZtKDGR+vcnX18S3mni4ig6mqKjaeZMio8v/Ay8T2Lia17o1i2aNYtq1qS+fWnXLpJIqHdvCg2lJ09o5UrSSlmgY9OnTx89enRWVtbAgQMLzDDxhDLh4eH88OXLl69mmalbty4vU8FFRETwDi4uLnFxcUlJSbz92rVrarXaxcWFH6ampn7wwQd37949evSokDeh8jp27Fh0dLSTk1O3bt10PZbSQoClAwUig7i4OCG6IiL+dbzWG1JcXJylpaW5uTk/1NfXt7W15R1efW5sbOyrr3jhwgU+31OVFH8TsPjwC0SUn5+v6yGALjVqRGfP0tKlZGREu3ZR48Z09er/dMjMpP8WNbyZ9HQKCaGOHalxYwoKopQUatiQAgMpLo727ycfH5JXvEyOP/30U8uWLR88eODr66tWq4X2WrVqderU6dtvv83NzSWioKAgiUTSv39/IoqKinr27BkRDR8+fPv27bdv3yaic+fOHT582M/Pj4i8vb2trKy++eYbIlKr1fPnz2/UqFHz5s2J6OrVq61atbKwsDh79qyQQapS49Wdx4wZI5VW/vhE11No7yK1Ws1vk/MiVp07d/7444+FR/m6bO3kH0uXLi2QcaBhw4Zz5sxhjBkbG69bt05o3759u0wmK1CxeOPGjcbGxrGxsWV0Obqyc+dOIurfv3+hj762nA6U3ooVK4yNjaVSab169VavXq3r4YCOPXzIundntWv/u7WwQQNGxGxs/r2dd/BgIU9p1owRMS+v/2lUq1lYGPPzY4aG/z7XwoL5+7Pw8PK4itKLiYnhOZxmz56t3X7//v26deuam5vXqlXL2Nj4999/5+21atX69ttvGWN5eXkDBw6Uy+X169eXSqUTJ04Ulnnw2Sk7Oztra2sHB4erV68yxtLS0gwMDHjCdOf//Pbbb+V6taJ69uyZvr6+VCrla2Aqu4oX/78D+B+k69ev37t3r1WrVnZ2dvzjC/f06VMi4uWKOXt7e57aRLjl9/TpU3t7eyJ69bk1atSQyWRCy8GDBydPnrx582ZHR8eyvq5yVvwMlrGxsaOjY2xsbExMTKHZ3qGUVq9e/cUXX/DP6A8ePJgyZcqSJUs+//zzESNGVPqlqfBWnJ3p2DGKiyPtBdmenhQbS+fO0cSJdOsWaS3yLsT9+7R9O23cSDExRERSKXl5kZ8f+fiQVt7viq5WrVp79uzx9PRcvHhx06ZNeZYsIqpXr97du3cvX76cm5vr7u4u3M47ePAg/5XR09PbvXv3nTt34uPjebQknNPb2zs2NjY8PFwul7dq1UpfX5+ITExMzpw5U+DVa9euXQ7XWEa2bt2qVCrff//9WrVq6XosYtB1hPeO8vX1JaItW7Ywxr755htbW1th2um7776ztrbWTqZy9epVIjp79iw/5MlOTp06xRjr06dPz549hZ6DBg3y+u/DoEaj+eGHH0xNTXfu3Fk+F1XOsrOzpVKpnp6eUNCqAG9vbyI6cOBAOQ+sysvNzR0zZgwRSSQSX1/fvXv3tm7dWv7f3RqFQtG7d+/Q0FDMHb7j+AzW0KHs9Ol/M1R9+WXBPtozWJcu/TtfRcRcXVlgIIuPL9j/0aNHP/744w8//CAklCogKytr69atgYGBf/zxR4GfwCtXrixbtmz16tUP/zdBVlRU1E8//bR69epwUafI+GYmQ0PDiIgIEU9btTVr1oyIhLm9yg4Blm7MnTuXiL7++mvG2KNHjwwMDGbNmpWdnX3p0qXq1at/+eWXjLGEhIRdu3bl5+drNJo2bdq0a9cuISHh6dOnXl5ejRs35hHY/v37ZTLZ5s2blUrlrl279PT0+I9mZmamj49PtWrVwsLCnv9Ht5dcFvj6s3v37hX66JQpU4ioQCo/KKW4uLg2bdoQkYGBwebNm4V2lUoVFhbm4+MjRFoODg4BAQEPyy3bI1QwQoDFGBs6lBExhYIVKCejHWBpNKx5c+bnx8LC2H93xv7H4cOHDQwM2rVr17t3bz09vUWLFhXokJKSUq9evdq1a/N3v06dOuX+V9Pnhx9+kMvlvXr16tixo76+/t69e3n7mjVrDA0N+/btO3DgQD09ve+++07E7wD/HOLk5KS9eRCKwktG8iT1uh6LOBBg6ca2bduIaPDgwfxw3759dnZ2UqlULpePGjWK13jft28f/bdO6/Hjx+3atZNIJFKp1MPDQzuk+P77701MTKRSqbGxsfCOM3/+/AJTlfr6+uV+lWWuZ8+eRCS8Vxbw448/EtH48ePLeVRV2JkzZ2xtbYmoZs2aRX3cj4+PDwwMFG7LSqVSLy+vTZs28WQi8O7QDrBiY5mxMSNinTr9T/BUYA1WoXEVp1ar69SpI5SaCQ4O1s5uw02dOtXJyYl/mIyKijIxMfnxxx8ZY3FxcQqFYsWKFbzbhAkTHBwc8vPz1Wr1wIEDjx49ytt//PFHPT09IWF66eXk5LRu3ZqIPD09MaH7Wv7+/kT0xRdf6HogokGApRt8L27jxo2FFpVKFRsbm6lVeEKtVhcI5J8+fZqcnPzq2ZRKZUxMTJWJ+ktu2rRpRLRkyZJCHy2+nA68qeDgYIVCwb+lhf4cFhAeHu7v7y+kPbSwsPD39+eLc+FdoB1gMcYWLfr39t+GDf/fp9BF7oW6fv06EV25coUfKpVKCwsLITsg5+TkNG/ePOFw2LBhPXr0YIytX7/e2Nj45cuXvJ2vsrhw4UKBl+CLMe7cufNGl1m8hIQEvl721dLOoC07O5svSnttzexKpPJvg6ycXF1dJRLJgwcPhH28MpnM0dFRO12vVCrlKxkFNjY2hW7EVSgUtWrVKtD5XYBMDeVDqVT6+/tPmDAhLy/P39//2LFjJdkQ7uHhERwcnJCQEBwc3KJFi/T09JCQEHd395YtW65cubKoFPxQVc2YQW5u/37x9OkbPz0mJoaIGjRowA8VCkXdunV5I6fRaOLi4oQOROTm5sY7xMTEODk5CbG+q6srz9Vc4CXu3bunp6ennfim9Ozs7Hbt2qVQKL7//vuNGzeKeOYqZufOnenp6e3bt2/YsKGuxyIaBFi6YWxs7ODgwGeedD2WSqz4EOq15XSgJBISErp167Zu3ToDA4Nff/01ODhYT0+v5E83Nzf39/ePiIiIjIwMCAiwtraOiIj49NNPHRwcfH19ebLmshs8VBwKBa1aRUSUmkqzZ7/x09PS0vT09AwMDIQWMzOztLQ04TAzM1OlUpmamgot5ubmvENaWpp2u0wmMzIyKvC2oFQqg4KC/P39tV9CFO3bt1++fDkRTZw4UUg0CgXw9Fdjx47V9UDEhABLZzC/Unp8BuvOnTuFPiqRSFCRsJQiIiLatWt3/vx5R0fHU6dOjR49+q1P1ahRo8DAwPj4+NDQUC8vL74tw9vb283NLSgoKDk5WbxRQwXl7U2+vkREGzbQ5ctv9tzq1avn5+dnZWUJLampqXxFIGdmZmZgYKAdcgkdqlevrt3Oz6P9XLVaPWbMmPz8/EWLFr3pRZXEpEmTxo8fn5ubO2jQoKdvMX1X1d2/f//s2bMmJiY+Pj66HouYEGDpDAKs0rO3tzc3N3/+/Ll2MjBtCLBKY+vWrZ06dXry5EmnTp3Cw8NbtWpV+nPq6+v7+PiEhYXFxMQEBgbWrl37/v37s2bNcnBw8Pb23rVrl0qlKv2rQIW1ciWZm5NGQ59+Sm80d8mTQl39L0l8VlZWVFSUdqYonm/zqlYW+WvXrvEOzs7Ojx49EmIsvhBQeG5aWlq/fv2uX78eFhZWdqVm1qxZw3+bBg4ciOIHBfAKjEOHDtWeaKwCEGDpDP72i6J+/fpU9LcR3+S3o1KpZs2a5efnl5OT4+/vf/z48Ro1aoj7EjVr1gwICIiOjubJHaRS6bFjx3x9fWvVqjVr1qyoqChxXw4qCFtbmjuXiOjcOdq9+w2eWL9+/RYtWnz33Xc8Olm6dKlMJuvTpw8RxcXF8eKtQ4cO3bx586NHj4jo4sWLR44cGTZsGBG9//77hoaGgYGBRKRWq7/77rsmTZo0adKEiK5fv96qVSuJRHL27FntOS3R6enphYaGOjg4nDlzZubMmWX3QpWOSqXaunUrVbn7g0RINKo7R48eJaIuXbroeiCVG6/VpV2CXlvx5XSgUE+fPuVlVvX19devX18+L5qYmLhixYrGjRsLb018jbyIe+ahnBXYRSjIz/9386CzM3NzK+kuQsbY9evX7e3t7ezs3NzcDA0NhRTKNWrU+P777xlj2dnZXl5eRkZG7u7uenp648aNE0rN7Nmzx8jIqH79+vb29ra2tjz557NnzwwNDYlIu9TMnj17RPoGFOL8+fN8N1K5/WZVfHv27CEiNzc3XQ9EfAiwdObJkydEVKNGDV0PpHLjayaK2gJ97do1ImrQoEE5j6ryunLlCi+14eDg8Oo+9nLAkzsY/1dRRVgjX/4jgVIqKsBi7P9zu/N/JQywGGMvX748cuTIvn37UlJShMaLFy/GxcXxrzUazeXLl3///fdXd/s/ffp03759hw8fFqL23NzcsFckJCS84YW+Gb6X0MDA4OLFi2X6QpXFBx98QETLli3T9UDEhwBLZzQaDU/KUCVzrJebXbt2EVGfPn0KffS15XRA27Zt2/gH+g4dOiQmJupwJBkZGcHBwR06dBAmtBo2bBgYGPjs2TMdjgreSDEBFmNs1Ki3CbCqho8//piI7Ozs4l8tBvSOiYuLk8lkCoVCO2KuMrAGS2ckEknx64egJJo3b/7hhx/26tWr0EcNDQ1r1aqVn5/Pl2VAUfiiq+HDh/NFVydOnCjT9SivZWZm5u/vf+bMmdu3bwcEBFSrVu327dt8LTySO1QNP/xA1ta6HoSOrFq1qkuXLomJiT4+Pnl5eboeji5t3LhRrVb369evWrVquh6L+BBg6RKWYJeei4vLtm3b+CfCQmG35mulpqb27NkzKChIX19/3bp1Qsb2iqBBgwaBgYGxsbGhoaG9e/dWqVQ8uUPt2rVnzZqFNHKVl7U1LVyo60HoiJ6e3s6dOx0dHc+dO/f555/rejiiUalU0dHRx44dW7ly5YQJE7y9vWvWrJmbm1tUf/bfDdMquLydiIjkuh7AOw0BVjlwdXU9fPjw3bt3+/btq+uxVETXrl0bOHDgo0eP7O3tf//993bt2ul6RIXgyR18fHzi4uK2bdv2888/P378OCgo6Pvvv+/evbu/v3///v3fKP0plIPly+nFC6pZs8gOEyZQ9eqk0ZDYW1QrgRo1auzbt69Dhw5r1qxp1qzZ+PHjdT2iN5aenv7w4cPo6Ohbt27dvn07Ojr69u3bOTk5BbpFRUVpb17RdvLkyaioKEdHRy8vr7Ifrw4gwNIlTK6UAx7F4ptcqN27k0eO7JCdnd2uXbvff/+dF02ryBwdHQMCAmbMmHHixImQkJC9e/ceO3bs2LFjtra2vr6+48aN43vvoSJ4773XdJBKadCgchlKheTu7h4cHDxy5MjJkye7ubl16tRJ1yMqTkJCAo+ihHCKV9ou0M3Ozq5Ro0bOzs4NGzbkX9SpU6eocwrZ22UyWdmOXkckWMqgQ9euXXN3d2/YsCEvPgplISAgYO3atSqVys/Pb8KECS1atND1iCoEtZq++oqCgqhLl721au0ODg7my9srl7S0tF27dv3000+8EjAReXh4+Pv7f/jhh9plPaHi2LCBMjLok08IE47c1KlTV69ebWtrGx4e7uDgoOvhEBEplcqoqCjtcOrOnTvZ2dkFuunr69etW1c7nHJ1dS35711GRoa9vX1OTk6BhLFVCQIsXcrJyTExMZHL5S9fvpTLK+VsYl5e3saNG69evWpmZjZ8+PCmTZu+2uf48eP79u1Tq9Wenp4DBgwQ2p8/f75u3bro6GhHR8exY8cK0yc5OTmbN2++ceOGhYXFoEGD3jokys/P/+yzz9asWSOR/P/PuYeHx9ixY4cNG1Z2KZsrvtRUGjaMwsJIoaCVK9nHH0t0PaLSioiICAkJ2bFjR2ZmJhGZmZn169dv5MiRVfXWQ+VlZUVpaZSaSlZWuh5KxaBSqXr06PH333+3bdv25MmTPEtWeSrh1JSlpaUwKcW/cHJykkrffhn3mjVrPvnkE29vb54SsmrS2f5FYIwxxnMO3b9/X9cDeRsajcbb29vOzm7GjBl9+/bV09M7ceJEgT6rVq2SyWRjx46dMmWKoaHh9OnTefvz58+dnZ0bN2785ZdftmnTpnr16jExMYyxrKys5s2bd+3adeHChX5+flKp9O3y/j19+rR79+5EpK+v/8svv9y6dSsgIMDGxob/2AsFW4Q8hO+O69eZszMjYjY27JX/rrKiVqtzcnKK7/Py5ctC25VKZX5+fkleJTs7mxc6lEj+DRn5GvkquQO8kqpVixGxx491PY6K5NmzZ/w+2qhRo8r0hXJzcyMjI0NDQwMDA/38/Dw8PISEc9oUCoWzs3Pv3r0DAgKCg4NPnz794sUL0Qfj7u5ORL/99pvoZ644EGDp2HvvvUdE+/bt0/VA3sa+ffskEsn169f54eDBgz08PLQ7ZGZmmpqaLly4kB9u3rxZJpM9fvyYMTZ37twaNWqkpaUxxnJycho0aODv788Yi4mJ+frrr4W4Z/Dgwb169XrTgQnZMu3t7bWzZebm5vLNaMItf16w5fE7836/cyczNmZEzN29nP7IZWVljRw5kn8ud3d3v3z58qt9li9fzmNfW1tb7aT8UVFRXbt2lUgkMpmsb9++ycnJvD07Ozs4ONjNza1bt26FvuidO3cCAgKqV6+uHU/v27dPpVKVxTVCyTVsyIhYZKSux1HBXL161cjIiIjWrl0r1jmfP39++vTp4ODggICA3r17Ozs7FzrhZGlp2aFDB39//8DAwNDQ0MjISLVaLdYYinL48GEisra2zs3NLevX0iEEWDo2depUIuJ1HiqdKVOmtGrVSjj866+/iEg7FeSxY8eISMiMnJuba2JismHDBsZYu3btJk6cKPRcsGCBk5PTqy/RrVu3Dz/88I1GtX37dv5W1aFDh6KSMsfGxgYGBjo5OfG3GKlU6uXlFRoaWoXzkWo0LDDw3/TZw4ez7Oxyel1/f387O7vTp0/HxMT4+PhUr149IyNDu8OePXtkMllwcHBiYuIPP/wglUr//vtvxphKpWrcuHHHjh3v379//fr1hg0bent7M8by8/Pr16/fs2fPnj17NmvWrJiXViqV+/bt8/HxEe6/Ozg48AKIZXjBUKw2bRgRO39e1+OoeLZt20ZEenp6J0+efNPnKpXKhw8f7tu3LzAw0N/fv0OHDoVWTdbT0yswNVXgl7Hc8H2Fnp6eOnn1coMAS8fWrFlDROPGjdP1QN5G//79h2rlab5z5w4RXbt2TWj59ddfDQ0NtZ/i6uo6f/58xpijo6N2WLl161Y9PT3hk1NUVNSqVasGDBjQpEkTviCgJFQqVUBAAH8r8ff3VyqVxfdXq9W80rCQ9snW1nbq1Kk3btwo4StWFhkZrF8/RsTkchYYWH6vm5mZqa+v//PPP/PDtLQ0fsdWu4+np6d2scguXboMHjyY/RedCwVPjhw5ItxM5/+zQUFBxQdYgvj4+MDAQGEhrVQqdXFxmTJlSnp6uggXCW/C05MRsbAwXY+jQuI5sWrUqBEbG/vazhcvXpw6dWqPHj1q164t3BPXVqNGja5du/r7+//www8HDx58+PBhBZnBff78OR+wUE2yqkKiUR2r1JkaXr58qb31jN/O56uMuaysLD6ZJDAyMuIdXn1ufn6+Uqnkh8+fP7927VpiYqJMJtM+YTGEbJkKhSIkJKQk2TKFiaukpKTg4OBmzZolJSWtWrWqadOmLVu2DAkJycrKKslLV3D37lGbNrR3L1lb0+HD9F8IWh6ioqKUSqWnpyc/tLCw8PDwiIyM1O5z69YtoQMRde/enXe4deuWnZ1dw4YNeXu3bt2kUil/6E3zoNrb2wcEBDx48ODo0aNDhgyRy+VRUVGrV6+2srIaPnx4aS4Q3hSfWCnZ7/Q7Z8mSJT179kxOTu7bt++rCaUKuH///qpVq44ePRoTEyOXy52dnb28vKZOnRocHBwWFpaUlJSUlPT3338HBwd//vnn77//vrOzsw6zIaSkpPz9998jR45s1apV7dq1GWPGxsa+vr66Gk/5qJQ716qSSh1g2drapqamCofPnj0jIjs7O6HFzs4uLS1NrVYLv9jPnj3jHezs7Ao819LSUgi5WrVq1apVKyIaNWrU2LFjL126VPxIrl+/PmDAgEePHlWrVm3Xrl1dunR5owuxtLT09/fnRYX5ZrSIiIgJEybMmDGjsm9GO3CARoygjAxq3pz++IP+uylaThISEohIuwhG9erVeSOnUqlSUlK0O9SoUYN3SEhI0G7X09OztLSMj49/68FIpVJvb29vb++4uLgvvvhi//79OTk527dv7969e1VNJF0B8V38VeKTi/hkMtm2bdtat2599erVCRMmbN68uZjOHTp0+P77711dXd3c3OrUqVNx9qHn5+fHxsZqb0uMjIxMSkrS7iOVSr/66itdjbDcVJT/kneWvb29mZnZs2fPUlNTrStbaa7GjRsvW7ZMpVLx3+2zZ89aWFjU1Mrc3LhxY41Gc/78+Y4dOxLRkydP4uLieCqHxo0bnzt3Tuh59uzZQlNEtm7des+ePcUPY+fOnWPGjMnOzm7RosUff/xRq1att74iDw+P4ODgFStWHDhwICQk5Pjx41u2bNmyZUuDBg1GjRo1ZsyYSlQwizFasoRmzyaNhoYOpfXr6X8nE8uDgYEBEeXn5wstSqXS3NxcOJTJZLwUt9CSm5vL42wDA4MCZdqUSqUoybocHR137txJRM7Ozo8ePSowowZligdYmMEqipWV1Z49e9q3b79ly5ZWrVpNmTKlqJ516tSZPn16eY6tUKmpqXfv3r179+69e/fu3bt39+7d6OholUpVoJuFhYWrq2t+fn61atWaN2/et2/f9u3b62TA5UrX9yiBtWzZkojOnDmj64G8seTkZH19/W+++YaXoHJycvr8888ZY6mpqWFhYXzBeNeuXTt16pSenp6dne3r61uvXj2+0Or48eMymWz37t2MsZMnTxoZGW3fvp0xduXKlY4dO/JlyGlpaR06dOjSpUtRA+CLrvjt/BEjRmSLvXK78m5Ge/GCDRjAiJhMVq6LrgrgU7MRERFCS+PGjWfPnq3dx8nJ6dtvvxUOp0+f3qJFC8ZYSEiIubm58K1+/vw5ER0+fFjoWfI1WEUJCgoiok8//bQ0J4E3MmMGI2JBQboeR8W2e/duiUQil8tfTXyjQ/n5+Q8fPgwLC1uxYoW/v7+Xl1dRCULt7Oy8vLz8/f1XrFgRFhb28OHDdzAhDsMi94pgxIgRRLR+/fpi+vzxxx+iRw+iCA0NtbS0NDY2lkgkvXr14ulSeOI4vqk+KiqqadOmcrncwMCgTp064eHhwnPnz5+vUChMTExkMtm0adP4b2BOTs6YMWNkMlmNGjX09fXd3d2joqIKfenU1NQePXoQkVwuDyzLIEKpVO7atatnz57CJucmTZrPn6958qTsXrNU7t//dzO8lRU7elSXI1Gr1S4uLgEBAfzw9u3bRHT27FntPpMnT27RogUPu/Py8lxcXObMmcMYu3PnjkQi+euvv3i34OBgc3PzzMxM4YmlD7D27t1LRD179izNSeCNzJ/PiNicOboeR4XH9+tYW1vratNrWlpaeHh4aGjovHnzfHx8PDw8Cp0/1tfXb9iwoY+PT0BAwKZNm8LDw4tKaPcOQoClewsXLiSimTNnFtUhPDyciMzMzPz9/U+fPl2eYyuJnJycmzdvxsfHCy1KpTIxMVE7mcqDBw/u3r37anqV9PT0GzdupKamFmh//vx5RETEw4cPi3rRGzdu8A9PNjY25fYhT9iM1rnzJCImlTIvLxYayl63W7Fc/fUXs7BgRKxpU1b096/8bNiwQSaTzZo166effnJxcenevTtvnzBhwrZt2xhj9+/fNzExGTBgwPr163v27GljYyMk1xg5cmS1atWWL1/+3XffGRkZffPNN7z93LlzwcHBAwcOdHR0DA4OPnTo0NuNjU+w1alTp9RXCSX1ww+MiGHS8LXUanWvXr2IqHnz5uUQssTHx4eFhQUHB0+dOpVPTRW6M1GYmgoMDNy3b987OzVVQiiVo3u///67j49P3759+efpV505c+aLL74QFnq7u7uPGTNm+PDhlpaW5TjMCmT//v0jRox48eKFu7v7H3/8wXOKlhuNRnPy5MuQENM//yS+67F6dfLzozFj6L8db7qhvejK15c2bKDCsjTrwJ49e7Zu3Zqdnd22bdvp06fzamWfffZZ+/btfXx8iOjmzZvLly+PjY11dnaeMWOGi4sLf2J+fv7q1auPHTsmk8n69+8/ZswY/qa/cePGgwcPCudv0aLFrFmz3mJgKpXKyMhIrVZnZmYalf8KtXfSunXk70/jxtG6dboeSoWXlpbWunXrqKio4cOHb926VazTlk+pQSDCGqwK4MaNG0Tk6upafLfbt28HBAQIi6zfzWIvGo0mMDCQ36r78MMPdTsXnZbGgoOZuzsj+vefhwcLDmZlUFXi9TIz2aBBjIhJJGzePPYu/VCUCt/GK1QjgLK2fTsjYkOG6HoclcSdO3fMzMyI6Icffni7M5Rwako7nzufmiqHfO5VHmawdE+pVPI1TC9fvnxtgp+8vLwjR45s2bJlz549arWaiBwdHYcPH/7xxx87lfMW/HL34sWLkSNH7t27Vy6XL1q0KKA8EzoVKyKCNm+mrVvp+XMiIkND6t2b/P3J05MKeysTX1QUDRhAkZFkZkZbtlDfvuXxolXDgAED/vzzz507d1b5lDwVxIED1KcPffABHTig66FUEnv37h0wYIBUKj1w4EDPnj2L6fnq1NS9e/deTeanUCgcHR21Kzc3a9as0MzvUFq6jvCAMcb4vNTx48dL/pS4uLjAwEBeIpTegWIv9+7da9CgARFZW1sfO3ZM18MpRE4OCw1lXl7/lqMhYq6uLDCQ/VdA7/Wyslh4OAsPZ8XMp7x8+W8foSLRoUPM0vLfl7tzp8gn7t+/39PTs0GDBv369bty5cqrHR4+fDhs2LAGDRp06tRp06ZNQrtGo/nxxx/btWvXqFGjMWPGaC+22759u5eXV+PGjQcNGlToOSs+HqYvWLBA1wN5V/z9NyNinTvrehyVytdff01EVlZW2jt+3rrUYMXfBF1lIMCqEHiANWvWrDd9Ii/24ufnJ+zv4Dkzq9gtjwMHDvDkSc2aNav4heTu3WPz5rGaNf8NsxQK1rs3Cw1l+fmveeLFi/9/t/G/zXMFXb36b4fNmxljbPFiJpMxIjZwYHG3Jo8fPy6VSj/77LMDBw4MGjTI3Nw8JiZGu8OLFy9q1qzZtWvXffv2LVq0SCaTCTHWDz/8oFAoli1b9scff7Rs2bJBgwa8Us3y5cutra1DQkKOHj06bNgwc3Nz7dirstiwYQMRDR8+XNcDeVeEhzMi1qLF/zQ+ffo0PDy8mPowubm5V69evXXr1qsrIh4/fhweHv78+fMC7fyciYmJIg1cl9Rqde/evYmoVq1avr6+LVq0MC5sfaW+vn6TJk0GDx781Vdfbdmy5dKlS7oqNQgcAqwKoUWLFkTUo0ePtz5DWlpacHBw8+bNhV82njNTe1t7ZaS96Gro0KGVaAOwSsXCwpiPD9PT+zcksrdnAQHF7ezTDrBcXFhOTiF9CgRYkyYxiYQFBLDi10t4enp+8MEH/Ov8/PzatWtPnz5du8OqVauMjY2Ft+NJkybVq1ePd7axsZk7dy5vj4uLk8lkO3bsYIxduXLlwoULvD03N9fY2HjdunWv/75UMDzbrYeHh64H8q64e5cRsfr1/79l9uzZMpnMxsZGIpEMHz48/5UPIkeOHLGxsTEzM1MoFI0aNRI2F+fm5g4YMEAikdjY2Ojp6X333Xe8PS8vb/LkyYaGhrVr19bT0+vfv39Oob9LlUp6erqpqal2FmVLS0sPDw8/Pz9MTVVYCLAqhFGjRhGRRCJp2rTpH3/8UZpThYeH+/v7CzfUTU1N/fz8wipnbdUXL14MGDCAiGQyWWBgYCVdzp+QwAIDmYvLv4GRVMo6dGDBwezVWFE7wCJi/0U1/6NAgJWXx06efP0YzMzMtKOfSZMmdf7fmzR+fn69e/cWDnll5efPn9+7d4+ItG//tWnTptDMnNWrV1+zZs3rh1LB8HpNJiYmlfSnq9KJj2dEzM7u38N9+/bJZLI///yTMRYeHm5mZlZgNXdOTk61atUmTpyoUqkyMjLatGkj/OjOmzfP2to6MjKSMbZ9+3aJRHLy5EnG2O+//+7h4ZGSksIYi46OtrS0XLZsWTleYplYtWoVEdnY2Pz0008XLlxIS0vT9Yjg9RBgVQgZGRn29vbCR5M2bdqsX7++NJNPOTk5oaGhXl5ewoYRNze3wMBA/qZTKdy/f58X+rWysjpy5IiuhyOC8HDm78+Mjf+NkCwsmL8/0165JARYrVszIqavX8iaqgIBVkm8ePGCiP7Suum4aNEiZ2dn7T7dunWbMGGCcHjz5k0iunnz5okTJ4goKSlJeGjAgAE+Pj4FXiIiIkIikVy7dq2kY6pIeKb+Yu5PgYgyMhgRMzX993Dw4MGenp7Co5MmTWratKl2/+3bt+vr6wt3AA8fPkxEfJ2Ak5OTkMOWMda6deuPPvqIf52bmyu0N2/e/LPPPiuTiykvjx8/5vkR9uzZo+uxwBsoZE0clD8zM7P4+PiNGzc2btxYX1//4sWLY8eOrV69uq+vL1/Q/aYnNDAw4EkceLGXGjVq3L17d9asWY6Ojn369Nm1a9ertaIqlEOHDrVu3fr27dtNmjS5fPkyz9he1rKzs1++fFlMh7y8vPT09EIfevHihZInxSqahwcFB1NsLP34I7m7U3o6hYRQixbUpg0VKOo6fTrVqEFKJU2YQKXf5qvRaIhIe2+2VCot8ENV4JDfk+WTOq8+l59QkJub+/HHHw8bNqxZs2alHasuuLq6EhGfq4OyZmJCEgm9fEn8h+j+/fvaNenatm374MED7f63b992c3MTcv61a9eOiB48eJCXlxcTE1Pguffv3+df6+vrE1FmZmZwcPCDBw+GDx9etldVlhhj/v7+WVlZH374IZ/Rf2svX74s6h2My8/Pf/78eaF/HTIyMl7dkEhESqWy+LfNdxkCrApk1KhRN2/eTE9P55NPubm5u3bt8vb2btiwYVBQUEpKyluc09XVNTAwkKdC8fHx0Wg0Bw4c8PX1dXJymjVr1qNHj0S/ilJijAUFBfXu3Ts9Pb1v375nzpwpqtyViOLi4jw9PU1MTExMTDp27BgVFVWgg0qlmjx5srm5uaWlZa1atfbt2yc8dPr0aVdXV3Nzc1NT0+HDhwv5+lJSUubPn1+jRo2xY8dqn8rSkiZPpitXKDKSAgLIxoYuXaKTJ//n5UxM6JtviIhOnaItW0p7debm5iYmJsnJyUJLUlKSg4ODdh8HB4cCHXgjn1jVfigxMdHR0VE4zM7OHjhwoEwmCw4OLu1AdYSnwuJZ3aGsSaVkZEQaDfFflOTkZCsrK+FRa2vrnJycjIwMoSU5OVk7o7KZmZmenl5SUhKfjNd+yNramv/ccl9//bWZmdnHH3/85Zdfenh4lOlFlan169cfPXrUxsZm+fLlb32S58+f9+3b18zMzNLSsnHjxrw6SAHz58+3srKytrauUaPG2rVrhfbbt2+3atXKwsLCzMzMy8srISGBt0dHR3t7exsaGpqYmDRp0kRIhQ3/T4ezZ1C8e/fu8ckn/j+lUCh69+4dGhr66iLQkuPFXurWrcvPyZM7bNq0qYIUOszMzBw8eDARSSSSgICAclsW06FDhxYtWkRFRcXExHTu3LlJkyYFkuwtXLjQzMwsLCzs+fPnM2fO1NfXf/DgAWPs2bNnlpaWo0ePTklJuXjxop2d3ccff8wYS0pKsre3HzFiRLt27Xx9fYt56exstmUL4/fWhFuEBw8ytZq1bMmImLU1e/r0//u/xS1CxlinTp2EYWg0GldX12nTpml3WLp0qYWFhbAWeMaMGU5OTowxpVJpbm4e9F9t3mfPnikUCmGD4YMHD5o0aeLt7V2pV4QsXbqUiKZMmaLrgbwratRgRIxv76tfv/7ChQuFh3777TeZTKa9WHv69OmtWrUSDnNycoho7969PAjTrpI0Y8aMli1bar+QUqk8efKkpaVlZVwdyMXHx/Mg8rfffivNeQYPHly3bt3IyMiUlJTBgwfb2dllZWVpd9iyZYuent6OHTsyMzPXrFkjlUp5CbK8vLz69evzuCoqKqpZs2bdunVjjGk0miZNmowePfrp06fp6ek+Pj41a9asqkmC3hoCrIpOpVLxySe5XM6jInt7+4CAgGLq9L2WRqM5ffq0v7+/UB7EwsLC39//6tWr4g38jUVFRTVu3JiIzMzM+KLX8nH9+nUi+ueff/ghX3506tQp7T729vazZ8/mX6vV6po1a/LD1atXGxsbC29Va9asMTQ05Fsd+R+JsWPHFh9gadMOsBhj//zzb0qt8eP/v8/bBVh79+6VSqXff//91atXJ02aZGRkxAPEP//8c+PGjYyxZ8+e2djYDBo0KDw8fMOGDfr6+j/99BN/7ty5c01NTX/77bdLly716NGjTp06PBzfu3evubm5t7f3xYsXw8PDw8PDK34GjULt37+fSreHF94I3/Bx/z5jjHXv3n3UqFHCQ99++23NmjW1O69cudLGxkYIuSIjI+m/XRfm5uarV68Weg4cOLB///6vvty4ceM6V9q8W/379yci7Q0obyE5OVkqlfLNv4yxlJQUuVzOK4EKOnToMGzYMOGwc+fO/I2L73e5z/+3GAsLCyOie/fuMcbi4+OV/9VhjYiIIKLbt2+XZpxVDwKsSiMhISEwMFAo0yaVSjt06BAcHFyazAXp6enBwcE8SQTn4eGxYsWKV6svl7XDhw/zD2r169cv59/SHTt26OnpaU9Z2djYrF27VjhMS0sjIu2dmCNGjOjXrx9jbOLEifzzHHfr1i0i4tuauNIEWIyx4cP/3Xh45sy/LW8XYDHGfv3114YNG1paWrZt2/bkfzsPZ82a5efnx7++du1a9+7drays6tat+/333wtPVKlUc+bMqV27trW1da9evXhkxhj74IMPnP/X1KlT32xMFQNf9FOrVi1dD+Rd0bw5I/p3e8eSJUssLS2Tk5MZY9nZ2Q0bNvT399fuHBsbK5fLf//9d3746aefOjg48HjL19e3ZcuWfNYkNjbWyMgoJCSEMRYTE7N//37hDJ6enqUMUHSF1x80NzePi4srzXlOnTpF/7tVpVmzZl999ZV2H0tLy+DgYOFw7ty5jRs3ZowtX77c0dFRaM/Ly5NIJK9udT9//jwRlXKcVQ8CrMqHJ2IQEs3xyadS5tGOjIwMCAiwtrbm5xTWyJfPTboVK1bIZDL+QS09Pb0cXlHbsmXL7IRd44wxxho0aPD1118Lhzxs0t4i99lnn/GbEf3799eOn54+fUpER48eFVpKGWAlJjJzc0bEmjRhfPb9rQMsKIpKpdLX15dIJJU9aVxl0akTI2J8yjgzM7NJkyYuLi6fffaZh4eHvb093875yy+/CHcGP/vsM2Nj4wkTJvj4+MhkMiHYun//vrW1ddu2bT/99FMnJ6c2bdrwCZW9e/caGhoOHjx43rx5H3zwgYGBwenTp3VzqaXw9OlTvr/1119/LeWpfvvtN4lEor22xMvLS9hxyf678bp7926hZfXq1VZWVoyxmTNnuru7a5/Nysrq1VuukyZNat68eSnHWfVgkXvlwzOIxsfHBwcHe3h4pKenh4SEtGjRomXLlitXrnzO6+G9oUaNGgUGBsbFxfH19Uqlkq+vb9CgQVBQkPYaZ3Hl5uaOGjXq008/1Wg0AQEB/K5TGb1WUQwNDXNzcwuMSrh5SkT8a+1NgjyvJn+udjt/n9J+binZ2tKCBUREN2/SmjVinRX+h0wmc3FxYf9NZUFZMzEhIuI70kxMTM6dOzdt2rT8/HxfX9+rV6/yLRSNGjUaNmwY779s2bLt27cbGhq6uLhcunRp0KBBvL1evXrXr1/v27evSqUKCAg4efIkr+Xat2/f69evN2nSJDExsXXr1jdu3OjYsaMuLrRUJk2alJKS4unpybMkloaRkRFjLC8vT2gR3sE4hUIhl8sLvJUJb3EF3h6FhwQHDhxYv3796tWrSznOKkjXER6UVllMPt2/f3/evHlC1mCZTMYLHZZmff2rnjx5wnf3mJqa6jC/y759+yQSiZDEXKlUGhkZbdaaIMrNzZVKpaGhoULLBx988OGHHzLGpk+frv3x7uzZs0T0+PFjoaWUM1iMMZWKubv/mzcrJQUzWGVi4MCBRCQsUoEy5evLiFjpFm1XcXyfsrGxcWnW2gr4Aqk7Wln1atWqtXjxYu0+NWvWDAwMFA4/+eSTtm3bMsZCQkLMzMyEd36+mV17vcTu3buNjY3xu1MoBFhVRG5uboHMovXr1w8MDNS+7/6meKFDHx8fPT09fk47O7uAgADtgqNv7Z9//uET4PXq1bt161bpT/jWMjIyTE1N+eoNxtiuXbv09fULfN/ee++9gQMH8q9TUlIMDQ35G8rJkyclEonwzjVlypQCaRJLH2Axxs6fZ1IpI2Iff4wAq0zMnj2biObNm6frgbwTZs8+1aVL4NatlbI6eDlIT0/nWVTE2vyYl5dnbW09Z84cfnjmzBkiEupccSNGjGjRogVf3JadnS3s47l3755EIhF2Ha1atcrIyOjFixeMMZVKNW/ePHNz81JWH6nCEGBVNU+ePAkMDKxdu7aIk0+JiYkrVqzgW/w4fpvyrdfXBwcH86CtV69eFWGH/9dff21kZPTNN99899135ubmwmJtLy8vvlf55MmTcrl85MiRq1atatq0aePGjYUNyV26dHF2dl6+fPnUqVOlUumuXbt4e2hoaGBgYKtWrZo2bRoYGHj8+PHXDqOoAIsxNm4cI2IyGdu6FQGW+DZt2kREQ4cO1fVA3gnTpk0jouXLl+t6IMXJysoqPnmNUqksqpRyenp6oQkLsrOzS5LIgN8TbN++vbr4CqNvYu3atTKZ7IsvvggMDLSzsxs0aBBvHzp06Pbt2xljd+/eNTMz69Wr18qVKzt27Ghvb893HjDGxo0bZ2lpuWjRoq+++kpfX5/XfMzNzfX09CSijz76KPA/169fF2vAVQPWYFU1NWvWDAgIiI6O5pNPUqn02LFjvr6+tWrVmjVr1qspNEvC1tZ22rRpN27cOHnypJ+fn6GhYURExIQJExwdHadOnRodHV3yU+Xm5n700UcTJkzgyyb2799vYWHxFkMS14IFC9auXXvjxo1Lly4tWbJESOjn4OBgaGhIRF26dDl16pRUKj18+HDv3r1PnTolzOr99ddfY8aMOX78eGpq6qFDh3geLyJKSkqKjo52d3dv27ZtdHT0262NEwQGkrU1qdU0b15pTgOF48nckWu0fPCqL4WmBa8I7ty506ZNG552uFevXq+uQM3JyRk1apSpqam5uXn9+vVPaqUJPnz4sLOzs4WFhampqb+/v7Ds6fLly61atTIyMjI0NPT09Cwmw/Px48c3b95saGi4ceNGXlBBFB9//PGePXsSExPPnz8fEBCwfft23u7o6MiXvbq6ul66dMnJyenYsWOtWrW6ePEiv8NARD///PPixYuvXLny4MGDTZs2ffnll0SUl5dXt25df39/PT296P/wqlzw/3Qd4UHZ4pNPTZo0Ef7H+eRTgSxzbyQjIyM4OLhDhw78hAWmmosRGxvbqlUrIjIxMRG2AoGgmBksxlhIyP+UgsYMloh4/RAjIyMR5wygKIsXLyYi7TKCFYeQVzM2NvbOnTuNGjV6NUHal19+Wb169bNnz6akpIwfP97MzIxP9jx58sTIyGjKlClPnz79+++/rays+F22Fy9eWFtb//zzz1lZWbGxsR07duzevXuhr56RkcFXvi5durSsrxTKAQKsdwVP7sA/OxKRubm5v79/eHh4ac557dq1BQsWlLDzqVOneFZ6FxeXmzdvluZ1q6riAyy1mrVrhwCrrNja2hJRTEyMrgdS9f34449ENGnSJF0PpBCHDh2SSCTCMtODBw8SkfZKc6VSaW1tvWzZMn6Yk5NjZmbGDxcuXFitWjVhMcbChQttbGx4yK6dIGrp0qXVq1cv9NU//vhjImrdurV2LnuovHCL8F0hJHfYtGmTl5dXRkZGSEhIy5YtGzVqFBQUlJqa+hbnbNas2Zw5c0rSMyQkxNPTMzk5uWfPnpcuXdJezgUlJJVScDD9l88fRIaKhOWmIt8ivHXrVq1atYRiYt26deONQoeYmJjU1FTeTkQGBgbt2rXjHW7fvt2pUyeh5Ea3bt2ePXsmlPXkjSkpKTt27Ojdu/erL/3PP/8EBwcrFIr169fzvIBQ2SHAereYmZmNHDkyLCzs9u3bAQEB1apVu3379qxZsxwcHHx9fY8dO8YYE/cVlUrl2LFjhUVXBw4c0K7PCm+kSROaOFHXg6ii3NzcpFLpw4dxuh5I1WdqakpEmZmZuh5IIRITE6tVqyYcGhgYmJmZCeWNeQci0u5TvXp13iEhIaFAO2/khw8ePHBycnJ0dNTX1381ZVR2dva4ceMYY3PmzMHnzyoDAdY7qkGDBoGBgbGxsaGhob1791apVDyzaO3atWfNmhUTEyPKq8THx3fp0mXDhg0GBgabNm0KDAzEJ7NitG5NjBFj9P77RfZZterfPn5+5Tiyd0DTposUipeRkWN0PZCqryLPYL2aV5MnxtPuQG+Vdrh27drHjh07ePBgdnb26NGjC7zu119/HRUV1bRp04CAAHGvCHQIAdY7TV9f38fHZ//+/Y8fPw4MDHRycoqNjQ0KCnJ2dvb29t61a1d+fv5bn/zs2bMtW7a8ePFizZo1z5w544eIACowJyfr3FyDe/d0PY53QEWewXJwcIiPj1er1fwwOTlZqVTy5PJCByKKjY0VWp48ecIbHRwcnjx5IrTzPsLNQYVC4eLi4uXltXjx4l27dmlvTrx48eKqVavkcvmGDRuE7clQBSDAAiIiR0fHgICAhw8f8uQOcrlcSO4wbdq0mzdvvukJQ0JCunfvnpSU1Llz5/DwcJ6xHd5Ofj717UvNmpHY92/h/7m5ERFhCVY5qMgzWO+///6LFy+OHj3KD3/77TcbG5t27doJHezt7Vu0aLFjxw5+GB0dffny5T59+hBR7969T58+HR8fzx/auXNn586deRIEXm6Ze/nypUQiETJC80UUarV65syZeJ+sanS9yh7egFKpTEhIyM3NLaqDRqNJTEzkaXYLyM7OTkhIeHVzSn5+flJSUoH258+fBwcHN2vWTPg54WvkS1INV6lUjh8/nj+LZ4Ip2cVBcWrUYETsyRNdj6PqUquZoSGTSFgRySNBNDwLVO3atXU9kMJ99NFHNjY2S5YsmTNnjr6+/pIlSxhjqamp3t7eV69eZYz98ccfUql08uTJK1eurFevXseOHXldMpVK1bx584YNG65atcrf318mk/G670lJSTY2NgMGDFi3bt2KFSvs7Oy0qzt89dVXROTq6pqTk6ObC4YygwCr0liyZAmfWjc2Ni40OcKpU6f45hepVNqnTx8hQ3peXt64ceP4zHONGjWEmnpqtXru3LkmJiYSicTAwGDGjBmvli/kyR346xKRmZmZn5+fdiGqAuLj4/mnPQMDg9IXgQdBly6MiB09qutx6MKzZ88+++yzDh06vP/++1u3bn21g0qlWr16taenZ6dOnb755hvtAgORkZF+fn5t27b19fU9d+6c0K5Wq//888/BgwfzjR1ckyaMiJUudQm83tOnT4nI2tpa1wMpXH5+/qpVq/r27Tto0CCe5Zwxlp6ePnLkSKGo19GjR4cPH/7BBx/Mnz9f+2NnWlra119/3atXLz8/v3/++Udoj4uLmz59+nvvvdenT5+VK1cqlUrefu1anqtrU6lUevbs2fK6Pig/CLAqh/3790ul0l9//TUnJ2fHjh16eno7d+7U7pCWlmZtbT1y5Mi0tLRbt27VqVOHVyNmjH3zzTcWFhb//PNPVlbW3Llz9fT0eO28X375pUmTJvfv32eMHT9+XF9fX3g3KSA7O7tAoUO+Rj4lJUW726ZNm/iCA0dHx0uXLpXJN+Jd5e/PiNjq1boeR7nLz8/38PBo2LDhr7/+Om/ePJlMtnbt2gJ9AgICjI2Nly5dGhwcbG9v369fP94eFxdnYWHxwQcfbNu2bfjw4fr6+hEREYyx8+fP16tXz8XFxdTUdNWqVcJ5fHwYESsshAMx8VXkCoVC1wPRsfx85u7O9PVzFy48oOuxQJlAgFU59OnTp2fPnsLhoEGDPD09tTusW7fOwMBAqI21ceNGPT09PollZ2f31Vdf8XaNRuPk5DRz5kzGmFqtfvbsmXAGFxeXuXPnFj+MO3fuBAQECCUU9PX1a9euvXDhQj5Jxhs7duxYmgrTUKgffmBE7JNPdD2Ocvf7779LpVIh02NAQICtra32He3U1FSFQiFEXSdOnCAiHkh99dVXzs7O/Ca1RqNp37794MGDGWPJycmRkZGMMVdXV+0Aa84cRsT+K4kLZYhPqAsTOe+mRYsYEXNyYiVYeQGVEha5Vw537tzp0qWLcNi5c+c7d+5od7h79667u7uZmRk/7Nq1a35+/oMHD9LT0xMTE7t27crbJRJJp06dbt++TURSqdTa2pq379q1Ky4urtD0d9rc3Nx4coddu3b17NkzLy8vJiZmzpw5BgYGv/zyCxE1a9YsLCyMZ2wHEb2zS7DPnTvXokULZ2dnfjho0KCkpCTtUm4RERF5eXlCCciuXbtWq1bt3LlzRHT06NH+/fvzv+USiWTQoEFnz54lourVqzdq1OjV13J1JXonv8nlj69zr5gbCcvH3bu0aBFJJBQSQv/V14CqBgFW5VAg/V21atWSk5OFvcRElJCQYGNjo92BN/K0eEIgxR/ijdz8+fPNzMyGDBmybNkyXijwtRQKxeDBgw8dOhQeHu7t7S2XyzUajUQiGTt27LVr1wwMDEpxoVC4dzbAio+P194kz78WNmoRUVxcnIGBgfDDL5FI+E57/lCB5yYnJ6tUqqJeiwdYyNRQDviyzoq5kbAcaDQ0bhzl5pK/P3l763o0UGZQd6NyMDIy4mnruJycHAMDA+2kncbGxnzpqNCBiExMTHgGPO3UeTk5OSZan5hmzJgxcuTIEydOfPLJJzVr1nztJJa2Fi1aHD16VKVS/fXXX82aNXNycnqba4MScHIiAwOKj6esrHfr865KpdL+Oed1SLTTs6lUKvn/1g+Sy+W8Q4Hn6unpMcZe7S9wdSWJhO7fJ7WakBC3TL3jM1grVtDZs2RvT4GBuh4KlCXMYFUODg4O2tnVY2JitD+aF9qBiBwdHW1tbaVSqXb6u5iYGCH3HREZGRnVqVNn7NixvXr1Wrdu3VuMTS6X9+vXD9FVmZJKycWFGKP793U9lPJlb2+fkpIiHPL0jNo/wA4ODllZWdnZ2dp9eIcCz+W75YuZYTU1JXt7ys0lrV8XKBPv8gzWo0c0bx4R0dq1ZGGh48FAmUKAVTl069Zt9+7dfCIqPz//999/7969e4EODx48uHz5Mj/ctm1bgwYN6tevr1AoOnTosG3bNt6enJx84sSJ/v37E1FSUtK1a9eEM6SlpSGJcEX2bt4lbNKkyeXLlzMyMvjh8ePHTU1NhSVZRNS4cWOJRBIWFsYP7969Gxsby1O4tW7d+tixY0LPY8eOaad2K9S7+U0uf+/sDBZj5O9PWVk0ciT17avr0UBZ0/UqeyiR+Pj4GjVqdOzY8YcffujevbuNjU1MTAxjbP369cOGDeN9evfubW9v/+23306aNEkqlf7222+8/fTp0wqFYsiQId9//33Dhg2bN2/O91X9/PPPxsbG06dPDwkJ8fPzk8vlf//9t46uD17v668ZEXvdRs+q5sWLF7a2tgMHDrx///6RI0esra35Hti4uLjly5fznLqDBg1ydnY+f/58ZGRkhw4dmjdvrlarGWPXr1+XyWTz589//PjxmjVrZDLZ/v37+WkfPXr08OFDZ2fnefPmPXz4MCsri7dPmsSI2PLlurnYdwf/jLdnz56iOqSmpt69e7c8h1Q+fvqJEbFq1dj/priBqgkzWJWDvb395cuX27Zte/78+ebNm1++fLlWrVpEVK1aNRcXF95n9+7dM2fOvH79enZ29tGjR4cMGcLbO3bseP78eQsLi4sXLw4dOvSff/7hM1UTJkzYv39/Wlran3/+aWxsfOHCBWGzIVRA7+YeN1NT08OHDycmJrq5ufn4+AwfPnzRokVE9OTJk0WLFr148YKIfvnll7Zt23bv3t3d3d3U1HTv3r1SqZSImjZtumPHjs2bNzs5OS1evHjNmjXCEsNOnTq1bNkyLS1t1apVLVu2/Oeff3g71rmXj9fOYO3atcvNzY0nPQ8JCdHel1N5xcfT7NlERGvXktaeJaiyJAzlzQAqg8uXqXVrataMtO7rgsiOHqX33qOuXenvv3U9lCpt0qRJa9euXbNmzaRJkwrtsHLlyu+++05YQieVSj08PLy9vb29vdu3b69QKMpxsKJ5/306fJh8fCg0VNdDgXKBGSyAysHN7d89bhpNwYeUSmXxz83LyyvqoaKeq71T792BGazy8doZrGnTpiUnJz98+DA4OLh3794KheLy5cvfffddt27dLC0tvb29g4KCeDrZchx1qWzcSIcPk7U1rV6t66FAeUGABVA5mJqSnR3l5PzPHreQkBA7OzsDAwNbW9uffvrp1WdduXKlZcuW+vr6hoaGH330kbDbTqPRzJgxw8zMzMDAwNXV9ejRo0L7d999Z29vr1AoHB0d16xZU/ZXVoHUqkVGRpSYSOnpuh5KlcYDrNfuInR2dvb399+/f//z58/DwsICAgI8PDxycnKOHTs2a9asli1bCvcQtVOjVUBJSfTFF0REK1cS0jC/Q3S9CAwASqp7d0bEDh369zAsLEwqlS5fvjw+Pv7HH3+USqV//fWXdn9hhXh0dPTp06ft7Oz8/f35QytXrjQ2Nv7zzz+fPHkyZcoUQ0PDR48eMcaWLVvm6Oh44sSJZ8+erVu3TiKRHD9+vFwvUteaN2dE7OJFXY+jSlu2bBkRffrpp2/x3OTk5NDQUH9//wKpapydnadOnRoWFpaTkyP6gEtp4EBGxHr10vU4oHwhwAKoNCZOZERsxYp/D/v16+fl5SU8+sEHH/T637fwDRs2KBSK1NRUfhgcHGxgYJCZmckYc3FxCQgI4O0qlcre3n7OnDmMsZcvX0ZFRQlnaNSo0axZs8rwkiqeoUMZEdu0SdfjqNJCQkKIaOzYsaU8D7+H6OPjwxNrcYaGhl5eXoGBgeHh4RqNRpQBl8ZvvzEiZmbGnjzR9VCgfOEWIUClUWCF0K1btzw9PYVHu3fvfvPmTe3+kZGRLVq0sLKy4oeenp65ubm8QmVUVJTwXJlM1rVrV/5cIyOjunXrCmdgjBkZGZXdFVVAWIZVDsRKNMrvIYaGhqakpISFhc2cObN58+a5ubnCPUQHB4cpUzK3baPkZDHG/eZSU2naNCKipUupZk3djAF0BQEWQKVRIA1mQkJC9erVhUerV6+emJio0VoD/2oHIoqPj09ISBAOhYd4o7Zr167dvXv3vffeE/s6KjQEWOXA0NCQiHisL8oJDQwMvLy8goKCrl69KtxDrFWrllpdbc0a0xEjyNaW6talCRNo1y4qz/ymU6dScjJ160bjxpXfi0IFgVqEAJVGgb/9+vr62tsDlUqlvr4+TwHFGRgYaP8B4xsGDQ0NebkY7efm5eXxv3mCzMzMUaNGjRw5snXr1uJfSQWGZO5lLTU1dcmSJba2tleuXLGxsWnevLmXl5eXl1fnzp1Fyb9QrVo1Hx8fHx8fIrpzJ/nwYQoLo1OnKDqaQkIoJIQMDaljR+rRg7y9qWlTkkhK/5qF++sv2r6djIxo3boyfBWosDCDBVBp8D1uCQnEK8c4ODjExsYKj8bFxWkX6Su0A2+0t7eXSCT8kIuNjdV+7tOnT9977z1bW9uff/65zK6mgqpfnyQSevCAVCpdD6Uqunr1qoeHx7lz5/Lz89u0aSOTySIiIoKCgry9vatVq9a/f/81a9bcF6/iZoMGNT77jA4epPR0Cg+nwEDq0IGUSgoLoxkzqHlzqlGDfH0pJIS0flHEkZFBH39MRLR4MWnddYd3ia4XgQHAG2jWjBGxS5cYY2zmzJlubm75+fmMMZVK1bRp0wLbss6cOUNEkZGR/HD27Nm2trYqlYox1r1796FDh/L21NRUIyOjrVu38sMLFy7UrFnTz88vOzu7vC6rYqlVixGxBw90PY4qZ8eOHXxJn4eHBy/29fLlSyH/gkRrksfW1tbHx2fTpk3CFg0RPX3KQkOZvz+rXZsR/f8/Z2fm789CQ1lGhgivMnYsI2Jt2zKVSoSzQWWEAAugMhkyhBGxzZsZYywmJsbCwuKDDz749ddf+/XrZ2ZmFh0dzRjbtm3bxIkTef+uXbvWrVt37dq1X331lVwuX7duHW/nKR4mTZr0yy+/tGzZ0tXVValUMsY2bdqkr6/fokWL4P/s3btXN5eqO97ejIgdOKDrcVQhKpUqICCAh1AjRowoNHZPSkria6fs7e2FSIvncA8ICAgLC8vNzRV9YA8fsuBg5uPDzM3/P9KSy5mHB5s3j4WHM7X6bU57/DiTSJi+Prt1S+wRQ+WBUjkAlcm8ebRgAX31FS1aRER0586d77//PiYmplatWtOnT2/UqBERhYaGnjt3bsWKFUSUmZn5/fffnzt3zsTExM/Pb9CgQcKpTpw48fPPP6empjZr1mzWrFl8zfvixYuvXr2q/YoNGjSYP39+OV6i7k2dSqtX09Kl/yaHhFJ6/vz50KFDw8LC5HL5okWLAgICXvuU6Ojo/fv3Hzhw4MyZM7m5ubzRyMioffv2fMFWixYtJKIua8rLo/PnKSyMjh6liIj/r5dQvTp5elKPHvTee2RnV6JTvXxJzZrRw4cUGEgluFaoshBgAVQm27fT8OE0eDDt2qXroVRda9bQJ5/Q+PEUEqLroVR+N27cGDBgQHR0tI2NTWhoaLdu3d7o6Tk5OWfPnj127NixY8euXLki/MGytbXt1KmTl5dX7969tWe8RJGVRX//TQcO0NGj9Pjxv40LFtCcOSV6+qef0sqV5OFBFy6QHBvJ3mEIsAAqkytXyMODGjem/814BWK6eJG+/5569sTW+tLatWvXRx999PLlS3d39z/++KN27dr/196dx1VV5g8c/957kUVEUXADFMQlwbAMbFQ008DMnNJmQF+YtmhoNa1TQZs5WYZbo+nPhLQUNRU0R2vUQms0NUVxy9DUVFRQcWcREC7P74+jd264pPgAwnzef3kOzzn3uTYTn+495zm3crbs7Ow1a9asWrVq+fLl9rdoBAYG/vnPfw4LC+vWrZuTk9Mtz/p39u6V776TlBR5910JCbmhQ9LTZcQImTpV2rfXOxdUMwQWUJ3k54ubmzg6Sn6+WCxVPRvgGpRS48aNe/PNN5VSUVFRM2bMKLMOyC2efMeOHSkpKSkpKT/++KPtO8QWLUIDAtaFh0t4uLRrp+vVgHIisIBqJjAwR2TvN9+08fevW9VzqTlOnJD8fBGRhg3F7rErv5OdLXl54uAgzZtX5tSqn5ycnCFDhixduvTGL7oqN/vvEF1cRqxbd+lTx8aN5b77JCxMHn5Yfr96SXmUlMiSJZf+/MgjctWPyUpLZfFiEZG2bSUo6FZfETUAgQVUM+Hh4atWrfr3v//dp0+fqp5LzfHYY5d+g3bvLj/8cPVlIQcOlIULxcdH/5pJNcmvv/7av3//3bt3e3h4LFy40P5pThXtxAlrSoolJUVSUuTYsUs7TSa5+24xPtbq2lWcnctz5txcqXv5P2dGj5Z33rnKmIsXL4XXm2/KmDHleRXUMCw0ClQzbdu2FZE9rDVeMdaskXnzqnoS1dY333zzpz/9affu3XfdddfmzZsrs65EpHFjy+OPy+zZkpUlv/0m8fESESFubrJtm4wbJ+Hh0qCBhIfL2LGSlibl/mzhgw94khJuCIEFVDN33HGHiPzKv+MrzCuvyKlTVT2J6kYpNXbs2EcfffT8+fMDBw7csGFDixYtqnA+/v4SHS1JSXL6tGzZIu+9J8HBUlQkq1ZJbKyEhEiTJpfWcLe7XP6GFBXJiy9WzKRRsxBYQDVDYFWcZs2kbl05dUrefruqp1Kt5Obm/uUvf4mNjTWZTHFxcbYV228HDg4SHCyjRsmWLXLihCQlSXS0NG8u2dmSnCzDh0uzZjfxHOj77xcR+e47WbCg4qeOao7AAqoZviKsOB4e8tprIiIzZsiGDVU9m2pi3759nTp1WrJkSYMGDVasWFGhl7TfIk9PiYiQ+HjJyPjvd4j16l16DnRkpDRoIF27XvoO0bbWqL2+fcVYyeuVV8TuQerAVRBYQDXj4+NTp06dEydOnD17tqrnUgO9+qr4+EhpqTz7LM97/mPLly+/995709PT27dvv3nz5vDw8Kqe0Y2yfYeYnS0//CBvvikhIVJaKuvXX/oOsWlTGTRI5s4te+CECWI2y/HjN7ruKP5nEVhANWMymdq0aSN8S1gxXF1l3DgRkZ07ZdKkKp7M7cy46OrPf/7zuXPnIiMjN2zY4O/vX9WTKg9HR7n/fhkzRjZvluzsS98h+vlJdrZ8+aVMn152/D33yJNPiohMmyYbN1b6dFF9EFhA9cNlWBVq4EDp2lVEZNQoOXy4qmdzW8rLy4uIiIiNjVVKxcTELFiwwNXVtaonpYGHx6XvEA8elD17ZMoU+dvfrjJszBipV09KS+X558VqrfRZoprgOUlA9UNgVSiTSaZNk3vukfx8GTFCli+v6gndZvbv39+/f/9du3bVrVs3MTHx0UcfrdCXy8nJ+fHHH0tKSjp37mw8krwMq9X6008/HT9+PCAgoN3vV3DPyspKTU11cnK677777BMwJydn/fr1paWlwcHBTZo0uerr3nGH3HHH1afUuLH84x/y8suydatMnSovvVT+d4cajE+wgOqH69wrWlCQPPeciMiKFbJ0aVXP5naycuXKe++9d9euXXfcccemTZsquq5++uknf3//Z599NjY21s/PLykpqcyA8+fPd+nSpU+fPnFxcR06dHjmmWdsq2fPmjXL39//nXfeGTZsWMuWLbdt22bs//rrr/38/N59992RI0f6+fkllOuZ3n/7m9x9t4jIu+9KZma53x9qNAWgutm+fbuIBAQEVPVEym/RokWBgYEuLi6tW7eeNWvWlQN+/fXXXr161a5du1GjRi+88EJBQYHtR3Fxcb6+vi4uLiEhIWvWrLHtj4+PDwwMdHV1DQgIuOo5r6N/fyWi7r77v3vOn1dNmyoR5eurLlxQSqkBA5SI8vG5ybdaU5SWlsbFxVksFhHp27fvuXPnKvoVrVZrmzZt+vfvb7ValVIxMTF169Y9c+aM/ZhXX33V29s7MzNTKbV27VqLxfLVV18ppY4dO+bi4jJ69GilVHFx8YMPPtihQwfjXXTv3v27774zDv/oo49cXFwuXrx4/Znk5CgRJaImTPjvztRUZTYrERUVpZRSRUWXxrz5pra/AVRrBBZQ/Vy4cMFsNjs6OhYXF1f1XMpj48aNFovlrbfe+uWXX+Li4sxm88qVK+0HFBQU+Pv79+jRIy0t7d///renp+dzzz1n/Gj69OmOjo4zZ878+eefn376aVdX14yMDKXUZ5995uHhsWjRov3790+aNMlkMv3nP/+58SldGVhKqXnzLv3KfP99pf63A6ugoGDw4MEiYjKZYmJijOKpaFu2bBGRrVu3GptnzpxxdHT88ssv7cf4+Pi89957ts2wsLABAwYopRISEurUqZOfn2/sX7NmjYj8+uuvZV4iOTnZbDbn5ORcfyZXDSyl1NChSkSZTGrtWgILZRFYQLXk6+srInv37q3qiZRHVFTUn/70J9vmQw891Lt3b/sBCxcutFgsxscSSqnp06c7OTkZvwXbtGnz/PPPG/tLSkq8vLzefvttpdTZs2d37NhhO0NQUNDrr79+41O6amAppXr2VCLK1VUdOVI2sCZOVLNnq8u/wWuyw4cPBwcHi4ibm5vx+VDlSEpKMpvNJSUltj2tW7f+4IMPbJtFRUUmk+lf//qXbc9rr73WsWNHpVRsbGxwcLBt//nz50XE1vGlpaX79+9fsWJF27ZtX3rppT+cybUC6+RJ5eGhRFTHjqqggMDC73ANFlAtVevLsHbs2PHggw/aNnv37r1jx44yA4KCgry8vIzNBx98sKioaPfu3QUFBXv37rUda7FYwsLCjGPd3d3bt29vO4Ojo2OtWrVufaqffipOTpKfX3bRo7w8GTVKnnhCmjaV4cNl3bpbf6nb1Jo1a0JCQtLS0lq3br1x48b+/ftX2kufOnXKzc3N+FLSUL9+/ezsbPsBSil3d3f7ASdPnhSRkydP2u+vW7eug4OD7djS0tJevXpFRESUlJQMHTq03DP09JSPPhIR2bxZ5s8v92lQMxFYQLVUrQMrKyvL/tatxo0bZ2dnl9gt65mVldW4cWPbpjE4KysrKyvLGG9/bOYV1xj/9ttv27dvDwsLu/Wptmkjr7wiIpKYKLt2/Xe/xSIffyydOklOjiQkSLducvfdMmWKnDlz6695G0lISAgPD8/Ozu7Tp09qampgYGBlvrqHh0deXp7VbiGEc+fOeXp62jYbNGhgMpmMT6fKDPDw8LDfn5eXV1JSYjvWYrH89ttvZ8+eHThw4P3333/uFhZlHzpUOnUSERk5stznQM1EYAHVUrVeqcHBwcE+p4qLi81ms9lsvs4AEalVq5bxoZT9j0pKShwdHe1PXlRU9MQTT/Tt27eH8UyTW/buu+LnJ6Wl8ssv/93p4iLDhslPP8nu3RITI40ayY4d8uKL4uUlkZHy9dfVfnmkwsLCp556avjw4SUlJTExMV9//bX9B0KVo3nz5larde/evcZmfn7+kSNH/Pz8bAOcnZ0bNWq0e/du257du3cb3577+vru37//4sWLxv709HRjp/35HRwcnn/++TNnzmzevLnckzSbJT5eHBxu+qHRqPEILKBaqtaBZdz2ZdvMysry8vKyD6wrBxg7mzZtajabjU1DZmamt7e3bTM3N7dfv34lJSVz5sz5w2nk5Uli4h/PtnZt+fjja/60bVuJi5MjR2TZMomIEKtVkpPlkUfEz09iY+XQoT8+/23o6NGj991336xZs+rUqZOcnGzciFD50wgJCfHx8Zl0eUH9+Ph4EbH/cllE+vXr9/nnnxsfVqWnp6ekpBhfYvbp0yc/P3/WrFkiopSaPHly27ZtjRtvP/zww6OXaygtLU1EbF9Gl0/79jJixK2cADVUFV8DBqBcjP7w9PSs6omUx4gRIwICAoyLl0tLSzt37jxw4ED7AStWrBCR9PR0YzMuLs7d3b2wsFAp1bFjxyjjtnil8vPz3d3dJ1y+8Dg9PT0gIKBPnz43soLAvn3qzjuViJo7V6lrX+Ru07fvpUuYr38X4dGjKi5O+ftfGmw2q7AwlZSkior+cEa3i7Vr1xpfwrZq1ernn3+u2sksX77cxcWlS5cuDz74YK1atT799FNjf7169Yw/Hz9+vHXr1n5+fo899lj9+vUfeeQR20Xx48aNq1Wr1kMPPdSxY8c6deoYK3oUFxdHRUV5eno+/vjjkZGRzs7OI0aM+MNpXOsid5vz55WXFxe543cILKC6qlu3rly+zrd62bdvn5ubW2Rk5JIlS5566ilnZ+ft27crpZYuXfr3v/9dKWW1Wjt37hwQEDB//vyPP/7Y2dl57NixxrFff/212Wx+4403Fi9e3LNnTx8fHyOn/vWvf7m5ud11110LFixISkpKSkpatWrVtSawcqWqX1+JqDZtlFFxfxhYhw6p2rVvdJkGq1WlpKjBg5WLy6VfuvXrq+hoZXeb420qPj7e+B62d+/eZVacqiqHDh369NNPJ0+evGvXLtvO+fPn29ZcyMvLW7BgwYQJE1asWFFaWmp/7LZt2yZNmhQfH3/06FH7/evXr584ceKECRPWrVt3I3PIzVX166v69dXUqdccM2/epTH/+MeNvznUZCZ1edFbANXLvffeu3nz5nXr1oWGhlb1XG7a1q1bP/zww4MHDzZr1iwmJqZLly4iMm/evG+//TYxMVFEzp49O2rUqHXr1rm6ukZFRQ0fPtxkMhnHLlu2bOrUqadOnQoKCho1alSLFi1E5L333tuwYYP9S7Rt23bKlClXvvTkyfL3v4vVKn37yty5Uq+eiEhenhQXi8Uidetec865uVJSImbzpUNuxLlzkpQkn34q27df2hMcLNHREhUlderc6EkqR1FR0XPPPff555+bTKY33njjww8/tL99D8DNIrCA6mrw4MFz586dOXPm008/XdVzqR4KCyU6WubMEZNJ3nhDxoyRSruyKC1NEhNl7txLtxm6uEjfvhIdLQ88IJe7sSplZmb+5S9/2bRpk7Ozc0JCgrGmKIBbwUXuQHVVra9zr3xHjkjXrjJnjri5yeLFEhdXeXUlIsHBMnmyZGZKUpKEhUlhoSQnS3i4BAbK2LFit7RTFVi/fn1ISMimTZuaNWu2bt066grQgsACqqtbXwpLKfXZZ5/17t27e/fuI0eOzMvLu3LMTz/9NGDAgK5duz755JP2r1VQUDB69Oj777+/V69e06ZNKy0tNfaXlJR88sknffr0CQ8Pf++99656zsq3dq2EhEhamrRuLRs3SiUulvk7zs4SESEpKZKeLq+/Lo0by549EhsrzZpJZKR8//0B219jpUlISOjZs+fx48e7d+++ZcsWY8V2ABpU8TVgAMpr586dInLHHXeU+wyjR492cnIaM2ZMfHy8r69vr169ygzYvHmzk5PToEGDEhMTe/fu3aBBgyNHjhg/6tevn5eX17Rp08aPH1+7du3Y2Fhj/1//+te2bdvOmDHjiy++aNmyZZln4FSJ+HhVq5YSUX36qLNnq3o2dkpKVEqKiohQDg7KyUk1aNDG29s7Jibmt99+q4RXLywsHDZsmPGLIDo6+loPPC4qKtqxY0d6enqZ68ft7du3b+vWrflXPDYoNzd369atBw4cuPKQ/fv3X/UQoMYgsIDqqrCw0GKxODg4FJVrDYD8/HxXV9dx48YZm5s2bRKRH3/80X5Mv379unbtavxmLSoq8vX1fe2115RSxupB33//vTFs2rRpTk5OZ8+eLS0tjY+Ptz1D8JtvvhGRrKyscr/HW1RQoJ588tLjeGNiVKU8obg8jh5VkycfbtmypZE7ZrO5V69eCxYsMFamqAiZmZmdO3cWEWdn51mzZl1r2KpVqxo1auTm5ubo6NiuXbv9+/eXGXDy5MnQ0FCLxVKvXj03N7d58+bZfjRz5szatWu7u7ubzeaePXva1s44deqUcYi7u3uZQ4CahMACqjF/f38Rsb99/cYZ99wdPHjQtqd58+ZxcXH2Yxo1ajRp0iTb5gsvvNC5c2el1JQpUxo2bGj7SMN4xFtKSkqZl9i6datU3ROpjxxRHTsqEVWnjlq0qEqmcNO2bNkSHR1du3Zto7Tc3d2jo6O3bdum/VWaN28uIj4+Pqmpqdcadv78eU9Pz6FDhxYXF58/f75z585dunQpMyYqKqpVq1aZmZlWq/X99993dHQ0/heVnp7u4OAwfvz40tLSjIwMX1/fZ555xjhk0KBBtkNGjx5tOwSoYQgsoBozHv3Rv3//chybnJxsMpmKi4tte0JDQ1944QXbZlFRkclk+uqrr2x7xo4d27x5c6VUbGzs3b9fM8rFxeXKD0ImTpzYqFEja1V8cLR2rWrcWImoVq1UVS+WedPOnTsXHx9/zz332K7lCA4OnjRp0unTp2/95ImJiS4uLiLSrVu348ePX2fkl19+WatWrZMnTxqbKSkpIrJv3z7bgLy8PEdHx88++8zYLC4ubtiw4UcffaSUevvtt40H3Rg/mjx5cp06dS5evJifn+/k5JSQkGA7pFGjRmPGjLn19wXcbrjIHajG7r33XhFZsmSJs7Pzo48+mn0zd6Nd9QmAtme3iYixIrb9Yki1atUyBhQXFzs4ONifzWKx2B8rIhkZGR9++OH7779f+U9ZSUiQBx6QEyekd29JTZU776zk179V9erVi46OTktL27VrV0xMjIeHR1pa2ssvv+zt7R0ZGWksoFqO05aUlMTGxg4ZMqSgoCA6Onr16tX2j82+0t69e9u0aWN7QLLxlaLtyYAikpGRcfHiRdsybA4ODiEhIcaAvXv3durUyfaPvnPnznl5eVlZWRkZGUVFRVc9BKhhCCygGktMTOzWrZvZbC4qKlq2bFnz5s0jIyO//fbbG7kZzcvLy2q1njp1yrbnxIkT9s/1My6gsY822wAvLy/7/fn5+Xl5eT4+PrY9R48e7dWr12OPPRYdHX2L7/GmFBXJ0KEyfLiUlEhMjHzzjdSvX5mvr1m7du3i4uIyMzOTkpLCwsKKioqSk5PDw8Pbtm07duzYEydO3PipTp061atXr7Fjxzo5Oc2cOdO2Yvt1nDhxor7dX5+rq6uzs/Px48ftB4iI/RhPT09jQJljPTw8ROT48ePXOQSoYQgsoBpzdnZeu3Ztfn7+qFGjHnjgAavVmpyc3Lt37+bNm8fGxh44cOA6xwYGBlosllWrVhmbR44c2bt371133WU/JigoyPhiyLB69WpjQPv27Q8fPmxbgmvVqlUmkykoKMjYXLNmTUhISHh4eHx8vKkSl9HMzJTu3eXzz8XZWWbPlrg4qYSlyNPS0qZMmTJr1qxrfXyYmZk5c+bM//u//9u1a5f9/tLS0hUrVnzyySeLFi0qKCiw/1FBQcHixYsPXX5StJOTU0REREpKSkZGRlxcnK+v7969e2NjY729vcPDw5OTk0tKSq4/yW3btoWEhPzwww/e3t5r1qy5wZVp69Wrl5+fb9ssLi4uKipyd3e37TEe1mQ/Jjc31xhQ5tjc3FwRcXd3v84hQE1T1d9RAtAmKysrLi7O/ma0sLCw2bNnX7hw4arjBw8e3KxZs/Xr1+/Zsyc8PLxNmzbGvfozZ85MS0tTSiUnJ1sslvj4+MOHD48aNcrBwcHYX1JSEhQU1LVr1/T09NTU1JYtW0ZERCilSktLJ0yYUKtWrbfeeuu3y3Jycirhva9bp5o0USKqWTO1ZUslvKBSSo0cOdLR0TE8PDwoKKhevXobN24sM2DVqlW1a9cODg7u2bOng4PDxx9/bOy/ePFieHh4/fr1+/bt6+3tHRAQYDxTMjs7+913323YsKGIjB8//qovarVaU1JSIiIibB9BNW3aNCYmxv7qKHtz5841LroKDQ09duzYjb+7qVOnNmjQwHaV3u7du0XE/qJ445OnlStX2vYEBQW98cYbSqnnnnvOuB/C8NVXX5nN5tzcXOMTrBUrVth+1L59+9dff/3GZwVUFwQWUAPd4M1oubm5TzzxRO3atS0WS48ePWy/oQMDA6dMmWL8+ZNPPmnatKmItGrVavHixbZjDx482KtXLwcHB2dn56ioKOMm/GPHjtW/wvz58yv6/cbHK0dHJaK6d1cnTlT0q12SkZHh4OCQmJiolLJarX379r3nnnvKjGnfvv2gQYOM2y0nT57s6OhoLCQWHx/v4uKye/dupdSpU6d8fX1ffvllpdSWLVveeuut1NTUoKCgawWWzbFjxyZNmmT74FBEgoOD4+PjbYtLFRQUdOzY0fhRdHT0zS7n8euvv5rN5oULFxqbr7/+esuWLcvcstChQwejrdXllT62bNmilPrhhx/MZvPPP/+slCotLX344Yf79u1rDLvnnnv++te/Gn9OTU0Vkc2bN9/UxIBqgcACaqwbvxntOmtIXn/AHx5Y0QoL1TPPKBEloqKj1TUWy6wQcXFxxnVsxqbxZWtGRoZtwPbt20XE1rUFBQVubm7x8fFKqT59+tgiQyk1cuRIPz8/+5O3b9/+DwPLxuhpV1dX459yvXr1hgwZ8s9//tO41MlkMk2fPr187/HVV191dXUdMWLEgAEDLBbLggULlFJZWVn+/v7GR1k//PCDk5PTQw899OKLL3p6ekZGRtqOfeihh5o0afLSSy+Fh4fXrl3bVlH/+c9/7A+x9RlQw3ANFlBj3fjNaH94pdS1BlTmJVZXOn48v0cP+ewzcXGRuXMlPl7+6LptnQ4ePNi2bVvbjXLt2rUTkYyMDPsBIhIYGGhsOjs7+/v7GwMOHTp0p93Nje3atTty5IjVai3fTIwPrjIzMz/99NOQkJDz588nJia+8sorZ8+etVgsCQkJw4cPL9+ZJ06cOH/+fCcnJz8/v40bNw4YMEBEXF1dhwwZYtyBeP/99xsXeCmlJk2aNH/+fNuxy5Yt++ijj6xWa2ho6M6dO0NCQoz93bt33759+1UPAWqUKg48AJWlsLDQuBnNVkVt2rSJi4u7/mJIty1jtcwuXTJ8fNS1F8usQBEREf369bNtXrhwQUSWLFli2zNz5kxnZ2f7Q+67774RI0YopZo2bTpx4kTb/pUrV4qI/SeLN/UJVhnbt28PDQ11dXX18/PTvkgpgBvEJ1jA/4pbvxnt9jFjxozQ0NDDhw/Xrfvq1q1y+UKjStWoUaOzZ8/aNk+fPi0i9itLNWzYsLCw0P4OwTNnzhgDGjZsWOZYR0dHXTfT3XXXXevWrcvLyzt48ODdd9+t5ZwAbhaBBfzPadasWUxMzIEDB4yb0cxm86pVqyIjI43FHfbv31/VE7weY7XMZ555pqioKDo6etmy+Q0bVs1MWrVq9csvv9iqdOfOnSaTqUWLFvYDRGTHjh3GZl5e3oEDB4wBLVq0sO03jvXz86v8FVkBVBz+/wz8jzIWcUhKSjp8+PCkSZPuvPPOY8eOjR07tnXr1iEhIQkJCcZ3XreVcqyWWXGioqJyc3Pj4+NF5OLFi+PHj+/evXuTJk2Ki4uPHz9utVoDAgI6deoUFxdnXFz1z3/+02w2P/zwwyJirAe7ZcsWETl69Ojs2bONy5sA1BxV/R0lgNvFlTejGdfIV/W8Ltm6davx7EVvb+8rV5yqElOnTnV0dOzQoYO3t7ePj8+ePXvU5dUKjEdcp6amNmzY0M/Pr3379s7OzvPmzTMOtFqtjz/+uLOzc6dOnerWrdutW7e8vDzjRz179gwODnZxcfHx8QkODv7uu++q6t0BuBUmVa5nWgGoqXJychYsWJCYmLh+/XpjT2Bg4JAhQ4YNG2Y88KRKfPnll8OGDSsoKAgNDV20aFGTJk2qaiZlHDp0aNOmTXXq1OnRo4ex8FhOTk5qampoaKixvGdOTs6aNWsKCwtDQ0O9vLzsj01LS9u3b5+Xl1fXrl1t3w+uWbOmuLjYNiYoKOj6TwwEcHsisABc3e7du2fPnv3555+fPHlSRJycnB555JHo6OgHHnigMldnKCkpeeedd8aOHSsi0dHRU6ZMcXR0rLRXB4DyIbAAXI/xGOnExMQVK1YY1xI1a9YsKirq2WefNb6wq1CnT58eMGDA6tWrnZycpk6dOmzYsIp+RQDQgsACcEOOHj06b9686dOnGw8hNpvNPXv2jI6O7tevXwVdab5jx47+/fsfPHjQy8tr0aJFnTt3rohXAYCKQGABuAmlpaXff/99QkLC0qVLL168KCJNmjSJjIwcNmyY/UPxbt2CBQuGDh164cKF4ODgr776qnnz5hpPDgAVjcACUB5nz55NTk6eNm2abT2n4ODg6OjoqKioOnXq3MqZrVbr22+/bVx0NXjwYOO5yBpmDACViMACcEvS0tISEhLmz5+fm5srInXr1n300UeHDBkSFhZWjrOdOXNm4MCBKSkpDg4OH3zwQUxMjO75AkBlILAAaFBQUPDNN98kJCSsXr3a+LdKQEDAE0888fTTTze84aXWd+7c2b9//wMHDnh6eiYlJfXo0aMipwwAFYjAAqDTnj17Zs2a9cUXX2RnZ8vlxR0GDx7cp08fi8VynQOTk5Ofeuqp/Pz8Dh06LFmypBJuUQSAikNgAdDv4sWL33777Zw5c5YsWWI8rc/Hx2fQoEEjRozw8/MrM1gpNW7cuDfffFMpFRUVNWPGDC66AlDdEVgAKlBWVtacOXMSEhIOHDgglxd3GDp0aN++fY1r4XNycoYMGbJ06VIuugJQkxBYACpcaWnphg0b5syZM3fuXOMZ0iaTKSgoqF+/frNmzTp8+LCHh8fChQsfeOCBqp4pAOhBYAGoPKdPn547d+77779/5swZ287AwMDly5dz0RWAmoTAAlAFvvjii/Hjxx87dszX13f16tVV+BhpAKgIBBYAAIBm5qqeAAAAQE1DYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGhGYAEAAGj2/wFk5f+x2ImxAAAAAElFTkSuQmCC",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw molecule with atom SHAP values\n",
    "atom_labels = {i: f'{atom_shap_values[i]:.3f}' for i in range(n_atoms) if atom_shap_values[i] != 0}\n",
    "mol_with_atom_shap = Chem.Mol(mol)\n",
    "for atom in mol_with_atom_shap.GetAtoms():\n",
    "    atom_idx = atom.GetIdx()\n",
    "    if atom_idx in atom_labels:\n",
    "        atom.SetProp('atomNote', atom_labels[atom_idx])\n",
    "img_atom_shap = Draw.MolToImage(mol_with_atom_shap, size=(800, 800), kekulize=True)\n",
    "img_atom_shap.save('atom_shap_values.png')\n",
    "\n",
    "# Draw molecule with bond SHAP values\n",
    "bond_labels = {bond.GetIdx(): f'{bond_shap_values[bond.GetIdx()]:.3f}' for bond in mol.GetBonds() if bond_shap_values[bond.GetIdx()] != 0}\n",
    "mol_with_bond_shap = Chem.Mol(mol)\n",
    "for bond in mol_with_bond_shap.GetBonds():\n",
    "    bond_idx = bond.GetIdx()\n",
    "    if bond_idx in bond_labels:\n",
    "        bond.SetProp('bondNote', bond_labels[bond_idx])\n",
    "img_bond_shap = Draw.MolToImage(mol_with_bond_shap, size=(800, 800), kekulize=True)\n",
    "img_bond_shap.save('bond_shap_values.png')\n",
    "\n",
    "# Display the images if running in a Jupyter notebook\n",
    "try:\n",
    "    from IPython.display import Image, display\n",
    "    display(Image(filename='atom_shap_values.png'))\n",
    "    display(Image(filename='bond_shap_values.png'))\n",
    "except ImportError:\n",
    "    print(\"IPython is not installed. Images are saved as 'atom_shap_values.png' and 'bond_shap_values.png'.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "chemprop_delete",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
